collegefishiesd/guitar-fretboard-notes

Guitar Single-Note Recordings

A dataset of 390 single-note guitar recordings spanning 6 strings and frets 0-12, recorded by two players on acoustic and electric guitars.

Dataset Summary

This dataset contains isolated single-note recordings from a standard-tuned guitar. Each recording captures one note played on a specific string and fret combination, covering the first 12 frets across all 6 strings (78 unique notes per source). The recordings are raw, unprocessed 44100 Hz / 32-bit float WAV files suitable for training note classification and pitch detection models.

Five recording sources from two players provide variety in playing style and instrument timbre. Player 1 (deb) recorded on an acoustic guitar. Player 2 recorded on both acoustic (eqm, eqm2) and electric guitar (ele, ele_natural), giving the dataset a range of tonal characteristics from warm acoustic to clean electric.

The labeling scheme derives entirely from the filename convention {source}_{string}_{fret}.wav. Each sample carries 12 metadata columns including MIDI number, frequency (Hz), pitch class, octave, and string/fret coordinates, making it straightforward to set up classification or regression tasks without any manual annotation.

Quick Start

from datasets import load_dataset

ds = load_dataset("collegefishiesd/guitar-fretboard-notes")

Dataset Structure

Splits

Split	Samples	Sources
train	234	ele, eqm, eqm2
test	78	deb
validation	78	ele_natural
Total	390

Splits are assigned by recording source (not random) to prevent data leakage. The train set uses Player 2's acoustic and electric recordings, the test set uses Player 1's acoustic recordings, and the validation set uses Player 2's electric guitar with natural tone.

Columns

Column	Type	Description
audio	Audio	WAV audio (44100 Hz, 32-bit float, mono)
source	string	Recording source identifier (deb, eqm, eqm2, ele, ele_natural)
guitar_type	string	Instrument type (acoustic or electric)
player_id	int64	Player identifier (1 or 2)
string_name	string	Guitar string name (low_E, A, D, G, B, high_E)
string_number	int64	String number (1=high E through 6=low E)
fret	int64	Fret number (0=open through 12)
note_name	string	Scientific pitch notation (e.g., E2, A4)
midi_number	int64	MIDI note number (40-76)
frequency	float64	Fundamental frequency in Hz (82.41-659.26)
pitch_class	string	Note name without octave (e.g., E, A, C#)
octave	int64	Octave number (2-5)
duration	float64	Recording duration in seconds

Statistics

Split Sizes

Split	Samples	Sources
train	234	ele, eqm, eqm2
test	78	deb
validation	78	ele_natural
Total	390

Source x String Recording Counts

Each cell shows the number of recordings for that source and string combination. Every source covers frets 0-12 on each string (13 recordings per cell).

Source	low_E	A	D	G	B	high_E	Total
deb	13	13	13	13	13	13	78
ele	13	13	13	13	13	13	78
ele_natural	13	13	13	13	13	13	78
eqm	13	13	13	13	13	13	78
eqm2	13	13	13	13	13	13	78

Visualizations

Representative waveforms from across the pitch range (all from deb source, acoustic guitar):

Low E Open (E2, 82 Hz)

A String Fret 5 (D3, 147 Hz)

High E Fret 12 (E5, 659 Hz)

Usage Examples

Load the Dataset

from datasets import load_dataset

ds = load_dataset("collegefishiesd/guitar-fretboard-notes")
print(ds)
# DatasetDict({
#     train: Dataset({...features...num_rows: 234})
#     test: Dataset({...features...num_rows: 78})
#     validation: Dataset({...features...num_rows: 78})
# })

Filter by String and Fret

# Get all open string recordings from the test set
open_strings = ds["test"].filter(lambda x: x["fret"] == 0)
print(f"Open string samples: {len(open_strings)}")

# Get all A string recordings across all splits
a_string = ds["train"].filter(lambda x: x["string_name"] == "A")
print(f"A string training samples: {len(a_string)}")

Basic Preprocessing

import numpy as np
import torch
import torchaudio

def preprocess(example):
    audio = example["audio"]
    waveform = torch.tensor(audio["array"], dtype=torch.float32).unsqueeze(0)
    sr = audio["sampling_rate"]

    # Resample to 16 kHz if needed
    if sr != 16000:
        resampler = torchaudio.transforms.Resample(sr, 16000)
        waveform = resampler(waveform)

    # Extract mel spectrogram
    mel_transform = torchaudio.transforms.MelSpectrogram(
        sample_rate=16000, n_mels=64, n_fft=1024, hop_length=512
    )
    mel_spec = mel_transform(waveform)

    # Log scale
    log_mel = torch.log(mel_spec + 1e-9)
    return {"mel_spectrogram": log_mel, "label": example["midi_number"]}

Minimal Training Loop

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset

class NoteDataset(Dataset):
    def __init__(self, hf_split, n_fft=1024):
        self.data = hf_split
        self.mel = torchaudio.transforms.MelSpectrogram(
            sample_rate=44100, n_mels=64, n_fft=n_fft, hop_length=512
        )

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        row = self.data[idx]
        wav = torch.tensor(row["audio"]["array"], dtype=torch.float32)
        spec = self.mel(wav.unsqueeze(0)).squeeze(0)  # (n_mels, time)
        label = row["midi_number"] - 40  # Shift to 0-based (MIDI 40-76 -> 0-36)
        return spec.mean(dim=-1), label  # Average over time -> (n_mels,)

train_ds = NoteDataset(ds["train"])
loader = DataLoader(train_ds, batch_size=16, shuffle=True)

model = nn.Sequential(nn.Linear(64, 128), nn.ReLU(), nn.Linear(128, 37))
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()

for epoch in range(10):
    total_loss = 0
    for features, labels in loader:
        logits = model(features)
        loss = loss_fn(logits, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch + 1}: loss={total_loss / len(loader):.4f}")

Intended Uses

• Note classification: Train models to identify which of the 37 unique notes (MIDI 40-76) is being played
• Pitch detection: Build frequency estimation models using the known fundamental frequencies as ground truth
• Audio ML benchmarks: Use as a small, well-labeled audio classification benchmark for quick experimentation
• String/fret prediction: Train models that predict not just the note but the specific string and fret position (useful for guitar tablature generation)
• Transfer learning: Fine-tune pretrained audio models on a domain-specific guitar task

Limitations

• Limited fret range: Only frets 0-12 are covered. Notes above the 12th fret (which exist on most guitars up to fret 19-24) are absent.
• Two players only: Recordings come from just two people. Models trained on this data may not generalize well to other playing styles, finger techniques, or pick types.
• Mostly acoustic: Three of five sources are acoustic guitar. Electric guitar representation is limited to one player.
• Single notes only: No chords, arpeggios, hammer-ons, pull-offs, bends, or other techniques. Each recording is a single cleanly-played note.
• Recording environment variation: Sources were recorded in different rooms and setups. While this adds some natural variation, it also means acoustic conditions are not controlled.
• No noise augmentation: The recordings are clean studio-ish takes, not noisy real-world captures. Models may need augmentation for deployment in noisy environments.

Contributors and Recording Details

Source	Player	Guitar	Notes
deb	Player 1	Acoustic guitar	78 recordings (6 strings x 13 frets)
eqm	Player 2	Acoustic guitar	78 recordings (6 strings x 13 frets)
eqm2	Player 2	Acoustic guitar	78 recordings (second session)
ele	Player 2	Electric guitar	78 recordings (6 strings x 13 frets)
ele_natural	Player 2	Electric guitar	78 recordings (natural/clean tone)

All recordings use standard guitar tuning (E-A-D-G-B-E), 44100 Hz sample rate, 32-bit float WAV format.

License

This dataset is released under the Creative Commons Attribution-ShareAlike 4.0 International License (CC-BY-SA-4.0).

You are free to share and adapt the data for any purpose, including commercial use, as long as you give appropriate credit and distribute any derivative work under the same license.

Citation

@dataset{guitar_fretboard_notes_2026,
  title={Guitar Single-Note Recordings},
  author={collegefishiesd},
  year={2026},
  url={https://huggingface.co/datasets/collegefishiesd/guitar-fretboard-notes},
  license={CC-BY-SA-4.0},
  note={390 single-note guitar recordings, 6 strings, frets 0-12, 44100 Hz}
}