【Kaggle】鸟叫识别

「爱情、让人受尽委屈。」 2023-01-15 14:21 168阅读 0赞

**目录**

赛题

识别声景录音中的鸟叫声

文件

数据下载地址

赛题理解

code

音频数据转图像

切分训练集和验证集

训练

测试

--------------------

# 赛题  #

## 识别声景录音中的鸟叫声  ##

![fe74dcbd7aee8b481e35179e7c344d58.png][]

您在本次比赛中面临的挑战是确定哪些鸟类在长录音中调用，因为培训数据是在有意义的不同环境中生成的。这正是科学家试图自动化对鸟类种群的远程监测所面临的确切问题。本次比赛以上一场比赛为基础，增加了来自新地点的声景、更多的鸟类物种、关于测试集录音的更丰富的元数据以及火车集的声景。

### **文件介绍** ###

**train\_short\_audio** - 大部分训练数据包括由[xenocanto.org][]用户慷慨上传的个别鸟类呼叫的简短录音。这些文件已缩小到 32 kHz，适用于匹配测试集音频并转换为 ogg 格式。培训数据应包含几乎所有相关文件：我们期望在 xenocanto.org 上寻找更多，是没有好处[的][xenocanto.org]。

**train\_soundscapes** - 与测试集相当的音频文件。它们都大约十分钟长，以奥格格式。测试集还具有此处所示的两个录制位置的声景。

**test\_soundscapes** - 提交笔记本时**，test\_soundscapes**目录将填充大约 80 个用于评分的录音。这些将是大约10分钟长，在奥格音频格式。文件名称包括记录的日期，这对于识别候鸟特别有用。

此文件夹还包含包含包含录制位置名称和近似坐标的文本文件，以及带有测试集声景录制日期集的 csv。

**测试.csv** - 只有前三行可供下载;完整的**测试.csv**是在隐藏的测试集。

*  `row_id`：行的ID代码。
 *  `site`：站点 ID。
 *  `seconds`：第二个结束时间窗口
 *  `audio_id`：音频文件的ID代码。

**train\_metadata.csv** - 为培训数据提供了广泛的元数据。最直接相关的领域是：

*  `primary_label`：鸟类的代码。您可以通过将代码附加到（如美国乌鸦）来查看有关鸟类代码的详细信息。`https://ebird.org/species/``https://ebird.org/species/amecro`
 *  `recodist`：提供录音的用户。
 *  `latitude` & `longitude`：录音位置的坐标。有些鸟类可能具有当地称为"方言"，因此您可能需要在培训数据中寻求地理多样性。
 *  `date`：虽然有些鸟可以全年拨打电话，例如报警电话，但有些则仅限于特定季节。您可能需要在培训数据中寻求时间多样性。
 *  `filename`：相关音频文件的名称。

**train\_soundscape\_labels.csv** -

*  `row_id`：行的ID代码。
 *  `site`：站点 ID。
 *  `seconds`：第二个结束时间窗口
 *  `audio_id`：音频文件的ID代码。
 *  `birds`：空间划定列表的任何鸟歌出现在5秒窗口。该标签表示未发生呼叫。`nocall`

**sample\_submission.csv** - 一个正确形成的样品提交文件。只有前三行是公开的，其余的将作为隐藏测试集的一部分提供给您的笔记本。

*  `row_id`
 *  `birds`：空间划定列表的任何鸟歌出现在5秒窗口。如果没有鸟叫，使用标签。`nocall`

## 数据下载地址 ##

[https://storage.googleapis.com/kaggle-competitions-data/kaggle-v2/25954/2091745/bundle/archive.zip?GoogleAccessId=web-data@kaggle-161607.iam.gserviceaccount.com&Expires=1619356084&Signature=OX5U42MLcM%2FpZL%2F6D5PXQ%2Bn5fp%2FZc9%2Bpoba38LWoQvDE4PSesfq%2FEnlQr7RXVQi22GiLeRuPYsY5tYuqiEHzBAR6vhT8d1jJH1qefNEeLJcXyKIrPiPmY2%2FHugeMlQLq3jYIUuXcQFp3s9tHP8roqjnWbOAPveHAaRVozq%2BMq8wit%2BNbvL%2Fg0n9pcamGxluroHvOLbe88IoDrHLO8j2Zpg4Z7p2oku8yR1VrrXjVmZB%2FZVbnZRS5vIh8P5bioXmnK2zuYxD4cJ5MxiBj6BNbJ4WpROH2gryWMfA670mh5VHFy6TjoldPp85keMepjVTzOolh43BlaLcPUbEo7qimcA%3D%3D&response-content-disposition=attachment%3B+filename%3Dbirdclef-2021.zip][https_storage.googleapis.com_kaggle-competitions-data_kaggle-v2_25954_2091745_bundle_archive.zip_GoogleAccessId_web-data_kaggle-161607.iam.gserviceaccount.com_Expires_1619356084_Signature_OX5U42MLcM_2FpZL_2F6D5PXQ_2Bn5fp_2FZc9_2Bpoba38LWoQvDE4PSesfq_2FEnlQr7RXVQi22GiLeRuPYsY5tYuqiEHzBAR6vhT8d1jJH1qefNEeLJcXyKIrPiPmY2_2FHugeMlQLq3jYIUuXcQFp3s9tHP8roqjnWbOAPveHAaRVozq_2BMq8wit_2BNbvL_2Fg0n9pcamGxluroHvOLbe88IoDrHLO8j2Zpg4Z7p2oku8yR1VrrXjVmZB_2FZVbnZRS5vIh8P5bioXmnK2zuYxD4cJ5MxiBj6BNbJ4WpROH2gryWMfA670mh5VHFy6TjoldPp85keMepjVTzOolh43BlaLcPUbEo7qimcA_3D_3D_response-content-disposition_attachment_3B_filename_3Dbirdclef-2021.zip]

# 赛题理解 #

我对赛题的理解：本次比赛是对鸟叫声的分类，共有397类，将数据集中的给定的训练集按5s窗口宽度截取音频时域波形图，傅立叶变换得到频谱图，再由神经网络识别。

在这里要注意：空间划定列表的任何鸟叫声出现在5秒窗口，所以要注意将训练集按照每5秒切分一张图像。

# code #

## 音频数据转图像 ##

音频转图像主要用到：librosa，将图像转为224×224的一维图像

安装命令：pip install librosa或者conda install -c conda-forge librosa

import os
    
    import warnings
    
    warnings.filterwarnings(action='ignore')
    
    import pandas as pd
    import librosa
    import numpy as np
    
    from sklearn.utils import shuffle
    from PIL import Image
    from tqdm import tqdm
    
    # Global vars
    RANDOM_SEED = 1337
    SAMPLE_RATE = 32000
    SIGNAL_LENGTH = 5  # seconds
    SPEC_SHAPE = (224, 224)  # height x width
    FMIN = 20
    FMAX = 16000
    
    # Code adapted from:
    # https://www.kaggle.com/frlemarchand/bird-song-classification-using-an-efficientnet
    # Make sure to check out the entire notebook.
    
    # Load metadata file
    train = pd.read_csv('../input/birdclef-2021/train_metadata.csv', )
    # Second, assume that birds with the most training samples are also the most common
    # A species needs at least 200 recordings with a rating above 4 to be considered common
    birds_count = {}
    for bird_species, count in zip(train.primary_label.unique(),
                                   train.groupby('primary_label')['primary_label'].count().values):
        birds_count[bird_species] = count
    most_represented_birds = [key for key, value in birds_count.items()]
    
    TRAIN = train.query('primary_label in @most_represented_birds')
    LABELS = sorted(TRAIN.primary_label.unique())
    
    # Let's see how many species and samples we have left
    print('NUMBER OF SPECIES IN TRAIN DATA:', len(LABELS))
    print('NUMBER OF SAMPLES IN TRAIN DATA:', len(TRAIN))
    print('LABELS:', most_represented_birds)
    # Shuffle the training data and limit the number of audio files to MAX_AUDIO_FILES
    TRAIN = shuffle(TRAIN, random_state=RANDOM_SEED)
    
    
    # Define a function that splits an audio file,
    # extracts spectrograms and saves them in a working directory
    def get_spectrograms(filepath, primary_label, output_dir):
        # Open the file with librosa (limited to the first 15 seconds)
        sig, rate = librosa.load(filepath, sr=SAMPLE_RATE, offset=None, duration=15)
    
        # Split signal into five second chunks
        sig_splits = []
        for i in range(0, len(sig), int(SIGNAL_LENGTH * SAMPLE_RATE)):
            split = sig[i:i + int(SIGNAL_LENGTH * SAMPLE_RATE)]
    
            # End of signal?
            if len(split) < int(SIGNAL_LENGTH * SAMPLE_RATE):
                break
    
            sig_splits.append(split)
    
        # Extract mel spectrograms for each audio chunk
        s_cnt = 0
        saved_samples = []
        for chunk in sig_splits:
    
            hop_length = int(SIGNAL_LENGTH * SAMPLE_RATE / (SPEC_SHAPE[1] - 1))
            mel_spec = librosa.feature.melspectrogram(y=chunk,
                                                      sr=SAMPLE_RATE,
                                                      n_fft=2048,
                                                      hop_length=hop_length,
                                                      n_mels=SPEC_SHAPE[0],
                                                      fmin=FMIN,
                                                      fmax=FMAX)
    
            mel_spec = librosa.power_to_db(mel_spec, ref=np.max)
    
            # Normalize
            mel_spec -= mel_spec.min()
            mel_spec /= mel_spec.max()
    
            # Save as image file
            save_dir = os.path.join(output_dir, primary_label)
            if not os.path.exists(save_dir):
                os.makedirs(save_dir)
            save_path = os.path.join(save_dir, filepath.rsplit(os.sep, 1)[-1].rsplit('.', 1)[0] +
                                     '_' + str(s_cnt) + '.png')
            im = Image.fromarray(mel_spec * 255.0).convert("L")
            im.save(save_path)
    
            saved_samples.append(save_path)
            s_cnt += 1
    
        return saved_samples
    
    
    print('FINAL NUMBER OF AUDIO FILES IN TRAINING DATA:', len(TRAIN))
    # Parse audio files and extract training samples
    input_dir = '../input/birdclef-2021/train_short_audio/'
    output_dir = '../working/melspectrogram_dataset/'
    samples = []
    with tqdm(total=len(TRAIN)) as pbar:
        for idx, row in TRAIN.iterrows():
            pbar.update(1)
    
            if row.primary_label in most_represented_birds:
                audio_file_path = os.path.join(input_dir, row.primary_label, row.filename)
                samples += get_spectrograms(audio_file_path, row.primary_label, output_dir)
    print(samples)
    str_samples = ','.join(samples)
    TRAIN_SPECS = shuffle(samples, random_state=RANDOM_SEED)
    filename = open('a.txt', 'w')
    filename.write(str_samples)
    filename.close()

下面的图像就是转换的结果：

![20210422214300422.png][]![20210422214316539.png][]![20210422214327685.png][]![20210422214329845.png][]

##  切分训练集和验证集 ##

使用sklearn.model\_selection 的 train\_test\_split切分数据集，按照7：3的比例切分训练集和验证集。

import os
    import warnings
    
    warnings.filterwarnings(action='ignore')
    from sklearn.model_selection import train_test_split
    import shutil
    
    filename = open('a.txt', 'r')
    str_samples = filename.read()
    filename.close()
    str_samples = str_samples.replace("\\", "/")
    samples = str_samples.split(',')
    trainval_files, test_files = train_test_split(samples, test_size=0.3, random_state=42)
    train_dir = '../working/train/'
    val_dir = '../working/val/'
    
    
    def copyfiles(file, dir):
        filelist = file.split('/')
        filename = filelist[-1]
        lable = filelist[-2]
        cpfile = dir + "/" + lable
        if not os.path.exists(cpfile):
            os.makedirs(cpfile)
        cppath = cpfile + '/' + filename
        shutil.copy(file, cppath)
    
    
    for file in trainval_files:
        copyfiles(file, train_dir)
    for file in test_files:
        copyfiles(file, val_dir)

## 训练 ##

模型采用EfficientNet的b3作为预训练模型，使用 datasets.ImageFolder加载数据集。差不多在20个epoch准确率能达到95%。

import torch.optim as optim
    import torch
    import torch.nn as nn
    import torch.nn.parallel
    from torch.autograd import Variable
    import torch.optim
    import torch.utils.data
    import torch.utils.data.distributed
    import torchvision.transforms as transforms
    import torchvision.datasets as datasets
    from efficientnet_pytorch import EfficientNet
    import os
    import time
    
    # 设置超参数
    momentum = 0.9
    BATCH_SIZE = 32
    class_num = 397
    EPOCHS = 500
    lr = 0.001
    use_gpu = True
    net_name = 'efficientnet-b3'
    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    # 数据预处理
    
    transform = transforms.Compose([
        transforms.Resize(224),
        transforms.ToTensor(),
        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
    ])
    dataset_train = datasets.ImageFolder('../working/train', transform)
    dataset_val = datasets.ImageFolder('../working/val', transform)
    # 对应文件夹的label
    print(dataset_train.class_to_idx)
    dset_sizes = len(dataset_train)
    dset_sizes_val = len(dataset_val)
    print("dset_sizes_val Length:", dset_sizes_val)
    train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)
    test_loader = torch.utils.data.DataLoader(dataset_val, batch_size=BATCH_SIZE, shuffle=True)
    
    
    def exp_lr_scheduler(optimizer, epoch, init_lr=0.001, lr_decay_epoch=10):
        """Decay learning rate by a f#            model_out_path ="./model/W_epoch_{}.pth".format(epoch)
    #            torch.save(model_W, model_out_path) actor of 0.1 every lr_decay_epoch epochs."""
        lr = init_lr * (0.8 ** (epoch // lr_decay_epoch))
        print('LR is set to {}'.format(lr))
        for param_group in optimizer.param_groups:
            param_group['lr'] = lr
        return optimizer
    
    
    def train_model(model_ft, criterion, optimizer, lr_scheduler, num_epochs=50):
        train_loss = []
        since = time.time()
        best_model_wts = model_ft.state_dict()
        best_acc = 0.0
        model_ft.train(True)
        for epoch in range(num_epochs):
            print('Epoch {}/{}'.format(epoch, num_epochs - 1))
            print('-' * 10)
            optimizer = lr_scheduler(optimizer, epoch)
            running_loss = 0.0
            running_corrects = 0
            count = 0
            for data in train_loader:
                inputs, labels = data
                labels = torch.squeeze(labels.type(torch.LongTensor))
                if use_gpu:
                    inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
                else:
                    inputs, labels = Variable(inputs), Variable(labels)
                outputs = model_ft(inputs)
                loss = criterion(outputs, labels)
                _, preds = torch.max(outputs.data, 1)
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
                count += 1
                if count % 30 == 0 or outputs.size()[0] < BATCH_SIZE:
                    print('Epoch:{}: loss:{:.3f}'.format(epoch, loss.item()))
                    train_loss.append(loss.item())
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)
            epoch_loss = running_loss / dset_sizes
            epoch_acc = running_corrects.double() / dset_sizes
            print('Loss: {:.4f} Acc: {:.4f}'.format(
                epoch_loss, epoch_acc))
            if epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = model_ft.state_dict()
    
        # save best model
        save_dir = 'model'
        os.makedirs(save_dir, exist_ok=True)
        model_ft.load_state_dict(best_model_wts)
        model_out_path = save_dir + "/" + net_name + '.pth'
        torch.save(model_ft, model_out_path)
        time_elapsed = time.time() - since
        print('Training complete in {:.0f}m {:.0f}s'.format(
            time_elapsed // 60, time_elapsed % 60))
        return train_loss, best_model_wts
    
    
    model_ft = EfficientNet.from_pretrained('efficientnet-b3')
    num_ftrs = model_ft._fc.in_features
    model_ft._fc = nn.Linear(num_ftrs, class_num)
    criterion = nn.CrossEntropyLoss()
    if use_gpu:
        model_ft = model_ft.cuda()
        criterion = criterion.cuda()
    optimizer = optim.Adam((model_ft.parameters()), lr=lr)
    train_loss, best_model_wts = train_model(model_ft, criterion, optimizer, exp_lr_scheduler, num_epochs=EPOCHS)

## 测试 ##

将测试集按照5秒做切分，然后转为图像，这里转的图像是一维的，但是使用datasets.ImageFolder在的图像3维的，我查看了一张图像，发现着3维的数据是相同。由于输入是3维的，所以测试时的一维图像也要转为3维的，我在transform 做了操作，加入 transforms.Lambda(lambda x: x.repeat(3, 1, 1))，这样就转为3维的图像，其他的参照训练集处理逻辑更改就可以。

import os
    import pandas as pd
    import torch
    import librosa
    import numpy as np
    
    # Global vars
    RANDOM_SEED = 1337
    SAMPLE_RATE = 32000
    SIGNAL_LENGTH = 5  # seconds
    SPEC_SHAPE = (224, 224)  # height x width
    FMIN = 20
    FMAX = 16000
    # Load metadata file
    train = pd.read_csv('../input/birdclef-2021/train_metadata.csv', )
    # Second, assume that birds with the most training samples are also the most common
    # A species needs at least 200 recordings with a rating above 4 to be considered common
    birds_count = {}
    for bird_species, count in zip(train.primary_label.unique(),
                                   train.groupby('primary_label')['primary_label'].count().values):
        birds_count[bird_species] = count
    most_represented_birds = [key for key, value in birds_count.items()]
    
    TRAIN = train.query('primary_label in @most_represented_birds')
    LABELS = sorted(TRAIN.primary_label.unique())
    
    # Let's see how many species and samples we have left
    print('NUMBER OF SPECIES IN TRAIN DATA:', len(LABELS))
    print('NUMBER OF SAMPLES IN TRAIN DATA:', len(TRAIN))
    print('LABELS:', most_represented_birds)
    
    
    # First, get a list of soundscape files to process.
    # We'll use the test_soundscape directory if it contains "ogg" files
    # (which it only does when submitting the notebook),
    # otherwise we'll use the train_soundscape folder to make predictions.
    def list_files(path):
        return [os.path.join(path, f) for f in os.listdir(path) if f.rsplit('.', 1)[-1] in ['ogg']]
    
    
    test_audio = list_files('../input/birdclef-2021/test_soundscapes')
    if len(test_audio) == 0:
        test_audio = list_files('../input/birdclef-2021/train_soundscapes')
    print('{} FILES IN TEST SET.'.format(len(test_audio)))
    path = test_audio[0]
    data = path.split(os.sep)[-1].rsplit('.', 1)[0].split('_')
    print('FILEPATH:', path)
    print('ID: {}, SITE: {}, DATE: {}'.format(data[0], data[1], data[2]))
    # This is where we will store our results
    pred = {'row_id': [], 'birds': []}
    model = torch.load("./model/efficientnet-b3.pth")
    model.eval()
    import torchvision.transforms as transforms
    from PIL import Image
    
    transform = transforms.Compose([
        transforms.Resize(224),
        transforms.ToTensor(),
        transforms.Lambda(lambda x: x.repeat(3, 1, 1)),
        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
    ])
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    # Analyze each soundscape recording
    # Store results so that we can analyze them later
    data = {'row_id': [], 'birds': []}
    for path in test_audio:
        path = path.replace("\\", "/")
        # Open file with Librosa
        # Split file into 5-second chunks
        # Extract spectrogram for each chunk
        # Predict on spectrogram
        # Get row_id and birds and store result
        # (maybe using a post-filter based on location)
        # The above steps are just placeholders, we will use mock predictions.
        # Our "model" will predict "nocall" for each spectrogram.
        sig, rate = librosa.load(path, sr=SAMPLE_RATE)
        # Split signal into 5-second chunks
        # Just like we did before (well, this could actually be a seperate function)
        sig_splits = []
        for i in range(0, len(sig), int(SIGNAL_LENGTH * SAMPLE_RATE)):
            split = sig[i:i + int(SIGNAL_LENGTH * SAMPLE_RATE)]
    
            # End of signal?
            if len(split) < int(SIGNAL_LENGTH * SAMPLE_RATE):
                break
    
            sig_splits.append(split)
        # Get the spectrograms and run inference on each of them
        # This should be the exact same process as we used to
        # generate training samples!
        seconds, scnt = 0, 0
        for chunk in sig_splits:
            # Keep track of the end time of each chunk
            seconds += 5
            # Get the spectrogram
            hop_length = int(SIGNAL_LENGTH * SAMPLE_RATE / (SPEC_SHAPE[1] - 1))
            mel_spec = librosa.feature.melspectrogram(y=chunk,
                                                      sr=SAMPLE_RATE,
                                                      n_fft=2048,
                                                      hop_length=hop_length,
                                                      n_mels=SPEC_SHAPE[0],
                                                      fmin=FMIN,
                                                      fmax=FMAX)
            mel_spec = librosa.power_to_db(mel_spec, ref=np.max)
            # Normalize to match the value range we used during training.
            # That's something you should always double check!
            mel_spec -= mel_spec.min()
            mel_spec /= mel_spec.max()
            im = Image.fromarray(mel_spec * 255.0).convert("L")
            im = transform(im)
            print(im.shape)
            im.unsqueeze_(0)
            # 没有这句话会报错
            im = im.to(device)
            # Predict
            p = model(im)[0]
            print(p.shape)
            # Get highest scoring species
            idx = p.argmax()
            print(idx)
            species = LABELS[idx]
            print(species)
            score = p[idx]
            print(score)
            # Prepare submission entry
            spath = path.split('/')[-1].rsplit('_', 1)[0]
            print(spath)
            data['row_id'].append(path.split('/')[-1].rsplit('_', 1)[0] +
                                  '_' + str(seconds))
            # Decide if it's a "nocall" or a species by applying a threshold
            if score > 0.75:
                data['birds'].append(species)
                scnt += 1
            else:
                data['birds'].append('nocall')
        print('SOUNSCAPE ANALYSIS DONE. FOUND {} BIRDS.'.format(scnt))
    # Make a new data frame and look at a few "results"
    results = pd.DataFrame(data, columns=['row_id', 'birds'])
    results.head()
    # Convert our results to csv
    results.to_csv("submission.csv", index=False)

[fe74dcbd7aee8b481e35179e7c344d58.png]: /images/20221022/0a085bc37fb4426bb2dc39c77b0aac26.png
[xenocanto.org]: https://www.xeno-canto.org/
[https_storage.googleapis.com_kaggle-competitions-data_kaggle-v2_25954_2091745_bundle_archive.zip_GoogleAccessId_web-data_kaggle-161607.iam.gserviceaccount.com_Expires_1619356084_Signature_OX5U42MLcM_2FpZL_2F6D5PXQ_2Bn5fp_2FZc9_2Bpoba38LWoQvDE4PSesfq_2FEnlQr7RXVQi22GiLeRuPYsY5tYuqiEHzBAR6vhT8d1jJH1qefNEeLJcXyKIrPiPmY2_2FHugeMlQLq3jYIUuXcQFp3s9tHP8roqjnWbOAPveHAaRVozq_2BMq8wit_2BNbvL_2Fg0n9pcamGxluroHvOLbe88IoDrHLO8j2Zpg4Z7p2oku8yR1VrrXjVmZB_2FZVbnZRS5vIh8P5bioXmnK2zuYxD4cJ5MxiBj6BNbJ4WpROH2gryWMfA670mh5VHFy6TjoldPp85keMepjVTzOolh43BlaLcPUbEo7qimcA_3D_3D_response-content-disposition_attachment_3B_filename_3Dbirdclef-2021.zip]: https://storage.googleapis.com/kaggle-competitions-data/kaggle-v2/25954/2091745/bundle/archive.zip?GoogleAccessId=web-data@kaggle-161607.iam.gserviceaccount.com&Expires=1619356084&Signature=OX5U42MLcM%2FpZL%2F6D5PXQ%2Bn5fp%2FZc9%2Bpoba38LWoQvDE4PSesfq%2FEnlQr7RXVQi22GiLeRuPYsY5tYuqiEHzBAR6vhT8d1jJH1qefNEeLJcXyKIrPiPmY2%2FHugeMlQLq3jYIUuXcQFp3s9tHP8roqjnWbOAPveHAaRVozq%2BMq8wit%2BNbvL%2Fg0n9pcamGxluroHvOLbe88IoDrHLO8j2Zpg4Z7p2oku8yR1VrrXjVmZB%2FZVbnZRS5vIh8P5bioXmnK2zuYxD4cJ5MxiBj6BNbJ4WpROH2gryWMfA670mh5VHFy6TjoldPp85keMepjVTzOolh43BlaLcPUbEo7qimcA%3D%3D&response-content-disposition=attachment%3B+filename%3Dbirdclef-2021.zip
[20210422214300422.png]: https://img-blog.csdnimg.cn/20210422214300422.png
[20210422214316539.png]: https://img-blog.csdnimg.cn/20210422214316539.png
[20210422214327685.png]: https://img-blog.csdnimg.cn/20210422214327685.png
[20210422214329845.png]: /images/20221022/62c9186a5b97456986ea625e2b012713.png