ディープラーニングを使用した音声分類のエンドツーエンドの例と説明

サウンド分類は、オーディオのディープラーニングで最も広く使用されている方法の 1 つです。音を分類し、音のカテゴリーを予測することを学ぶことが含まれます。この種の問題は、音楽クリップを分類して音楽のジャンルを識別したり、話者のグループからの短い発話を分類して声に基づいて話者を識別するなど、多くの現実世界のシナリオに適用できます。

[[388733]]

この記事では、このようなオーディオ分類の問題を解決するために使用されるアプローチを理解するために、簡単なデモ アプリケーションを紹介します。私の目標は、何かがどのように機能するかだけでなく、なぜそのように機能するかを理解することです。

オーディオ分類

MNIST データセットを使用して手書きの数字を分類することがコンピューター ビジョンの「Hello World」型の問題であると考えられるのと同様に、このアプリケーションはオーディオにおけるディープラーニングの入門レベルの問題と考えることができます。

まずサウンド ファイルから始めて、それをスペクトログラムに変換し、CNN と線形分類モデルに入力して、サウンドが属するクラスに関する予測を生成します。

さまざまな種類のサウンドに適したデータセットが多数あります。これらのデータセットには、解決しようとしている問題に応じてサウンドの種類を識別する、各サンプルのクラス ラベルとともに、多数のオーディオ サンプルが含まれています。

これらのクラス ラベルは通常、オーディオ サンプル ファイル名の一部またはファイルが配置されているサブフォルダー名から取得できます。さらに、クラス ラベルは、通常は TXT、JSON、または CSV 形式の別のメタデータ ファイルで指定されます。

デモ - 一般的な都市の音の分類

デモンストレーションでは、都市の日常生活から録音された一般的な音のコーパスを含む Urban Sound 8K データセットを使用します。音は、工事騒音、犬の鳴き声、笛の音など 10 のカテゴリに分類されます。各サウンド サンプルには、それが属するクラスがラベル付けされます。

データセットをダウンロードすると、次の 2 つの部分で構成されていることがわかります。

「Audio」フォルダ内のオーディオ ファイル: 「fold1」から「fold10」までの名前が付いた 10 個のサブフォルダがあります。各サブフォルダーには多数のものが含まれます。 wav オーディオ サンプル。たとえば、「fold1/103074 - 7 - 1 - 0. - wav」

「Metadata」フォルダ内のメタデータ: 「UrbanSound8K」というファイルがあります。ファイル名、クラス ラベル、「fold」サブフォルダーの場所など、データセット内の各オーディオ サンプルに関する情報が含まれています。クラス ラベルは、10 個のクラスそれぞれに対する 0 から 9 までの数値クラス ID です。のように。数字の 0 はエアコンを表し、1 は車のクラクションを表します。

一般的なオーディオの長さは約 4 秒です。以下に一例を挙げます。

データセット作成者は、メトリックを計算し、モデルのパフォーマンスを評価するために、10 倍のクロス検証を使用することを推奨しています。 ただし、この記事の目的は最先端の指標を達成することではなく、主にオーディオにおけるディープラーニングの威力を実証することであるため、分析は無視し、すべてのサンプルを 1 つの大きなデータセットとして扱います。

トレーニングデータの準備

ほとんどのディープラーニングの問題では、次の手順に従います。

このデータセットのデータ構成はシンプルです。

プロパティ (X) はオーディオ ファイルへのパスです。

ターゲットラベル（y）はクラス名です

データセットにはすでにこの情報を含むメタデータ ファイルがあるため、それを直接使用できます。メタデータには各オーディオ ファイルに関する情報が含まれています。

CSV ファイルなので、Pandas を使用して読み取ることができます。メタデータから特徴とラベルのデータを準備できます。

 # ----------------------------  
 #メタデータファイルからトレーニングデータを準備する
# ----------------------------  
 pandasをpdとしてインポートする
pathlibからPathをインポート
 
 download_path = Path.cwd()/ 'UrbanSound8K'    
 
 #メタデータファイルを読み取る
metadata_file = ダウンロードパス/ 'メタデータ' / 'UrbanSound8K.csv'   
 df = pd.read_csv(メタデータファイル)
 df.head() 
 
 #折り返しとファイル名を連結してファイルパスを構築します  
 df[ '相対パス' ] = '/fold' + df[ 'fold' ].astype(str) + '/' + df[ 'スライスファイル名' ].astype(str) 
 
 # 関連する列を取得する
df = df[[ '相対パス' , 'クラスID' ]]
 df.head()

トレーニングに必要な情報は次のとおりです。

メタデータが利用できない場合にディレクトリをスキャンしてオーディオファイルを探す

メタデータ ファイルを使用すると、物事ははるかに簡単になります。メタデータ ファイルが含まれていないデータセットのデータはどのように準備すればよいですか?

多くのデータセットは、フォルダー構造に配置されたオーディオ ファイルのみで構成されており、クラス ラベルはディレクトリから取得できます。この形式でトレーニング データを準備するには、次の操作を行います。

ディレクトリをスキャンし、すべてのオーディオ ファイル パスのリストを生成します。

各ファイル名または親子フォルダ名からクラスラベルを抽出します

各クラス名をテキストから数値クラスIDにマッピングする

メタデータの有無にかかわらず、結果は同じです。つまり、オーディオ ファイル名のリストで構成される機能と、クラス ID で構成されるターゲット ラベルになります。

オーディオの前処理: 変換の定義

オーディオ ファイル パスを含むこの種のトレーニング データは、モデルに直接取り込むことはできません。ファイルからオーディオ データを読み込み、モデルが想定する形式に適合するように処理する必要があります。

すべてのオーディオ前処理は、オーディオ ファイルを読み込んでロードするときに実行時に動的に実行されます。このアプローチは、画像ファイルで行う方法と似ています。オーディオ データ (または画像データ) は非常に大きく、メモリを大量に消費する可能性があるため、データセット全体を事前に一度にメモリに読み込むことは望ましくありません。したがって、トレーニング データにはオーディオ ファイル名 (または画像ファイル名) のみを保持します。 。

次に、実行時に、一度に 1 つのデータ バッチをトレーニングするときに、そのオーディオ データのバッチを読み込み、一連の変換をオーディオに適用して処理します。この方法では、一度に 1 つのオーディオ データ バッチのみがメモリに保持されます。

画像データの場合、最初に画像ファイルをピクセルとして読み取ってロードする変換パイプラインが必要になる場合があります。次に、いくつかの画像処理手順を適用して、データの形状を変更し、サイズを変更し、固定サイズにトリミングし、必要に応じて RGB からグレースケールに変換します。回転、反転などの画像拡張手順を適用する場合もあります。

オーディオデータの処理も非常に似ています。ここで、トレーニング中にモデルにデータを供給するときに後で実行される関数を定義します。

ファイルから音声を読み込む

最初に行う必要があるのは、「.wav」形式のオーディオ ファイルを読み込んでロードすることです。 この例では Pytorch を使用しているため、以下の実装ではオーディオ処理に torchaudio を使用していますが、librosa でも同様に動作します。

インポート数式、ランダム
輸入トーチ
torchaudio をインポート
torchaudioから変換をインポート
IPython.displayからオーディオをインポート
 
クラス AudioUtil():
 # ----------------------------  
 #オーディオファイルを読み込みます。信号をテンソルとして返し、サンプルレートを返します。
 # ----------------------------  
 @静的メソッド
def open (オーディオファイル):
 sig、sr = torchaudio.load (オーディオファイル)
リターン（sig、sr）

ステレオに変換

一部のサウンド ファイルはモノラル (つまり、1 つのオーディオ チャネル) ですが、ほとんどのサウンド ファイルはステレオ (つまり、2 つのオーディオ チャネル) です。 私たちのモデルではすべてのアイテムが同じ寸法を持つことが想定されているため、最初のチャネルを 2 番目のチャネルに複製してモノラル ファイルをステレオに変換します。

 # ----------------------------  
 #指定されたオーディオを必要なチャンネル数に変換します
# ----------------------------  
 @静的メソッド
def rechannel(aud, new_channel):
 sig、sr = aud 
 
 sig.shape[0] == new_channelの場合:
 # 何もすることがない
オーストラリアドルを返す
 
 (new_channel == 1 の場合):
 ＃変換する 最初のチャンネルのみを選択してステレオからモノラルに変更
レジスタ = sig[:1, :]
それ以外：
 ＃変換する 最初のチャンネルを複製してモノラルからステレオへ
resig = torch.cat([sig, sig]) 
 
戻り値((resig, sr))

正規化されたサンプリングレート

一部のサウンド ファイルは 48000Hz でサンプリングされますが、ほとんどのサウンド ファイルは 44100Hz でサンプリングされます。 つまり、一部のサウンド ファイルでは 1 秒のオーディオの配列サイズが 48000 であり、他のサウンド ファイルでは 44100 であるということです。すべての配列が同じ次元を持つように、すべてのオーディオを正規化し、同じサンプリング レートに変換する必要があります。

 # ----------------------------  
 # リサンプルは単一のチャネルに適用されるため、一度に1つのチャネルをリサンプルします  
 # ----------------------------  
 @静的メソッド
def resample(aud, newsr):
 sig、sr = aud 
 
 (sr == newsr)の場合:
 # 何もすることがない
オーストラリアドルを返す
 
 num_channels = sig.shape[0]
 #最初のチャンネルを再サンプリングする
resig = torchaudio.transforms.Resample(sr, newsr)(sig[:1,:])
 num_channels > 1の場合:
 # 2番目のチャンネルを再サンプリングし、両方のチャンネルを結合します
retwo = torchaudio.transforms.Resample(sr, newsr)(sig[1:,:])
 resig = torch.cat([resig, retwo]) 
 
戻り値((resig, newsr))

同じ長さに調整する

次に、無音部分を埋め込むか、長さを切り捨てて継続時間を延長するかのいずれかの方法で、すべてのオーディオ サンプルのサイズを同じ長さに変更します。 このメソッドを AudioUtil クラスに追加します。

 # ----------------------------  
 # パッド（または 信号を固定長'max_ms'に切り捨てる ミリ秒単位
# ----------------------------  
 @静的メソッド
pad_trunc(aud, max_ms)を定義します。
 sig、sr = aud
 num_rows、sig_len = sig.shape
最大長さ = sr//1000 * 最大ミリ秒
 
 （sig_len > max_len）の場合：
 #信号を指定された長さに切り捨てる
sig = sig[:,:max_len] 
 
 elif (sig_len < max_len):
 #パディングの長さ 追加 初めに​ 終わり 信号の
pad_begin_len = random.randint(0, max_len - sig_len)
 pad_end_len = max_len - sig_len - pad_begin_len 
 
 # 0を埋め込む
pad_begin = torch.zeros((num_rows, pad_begin_len))
 pad_end = torch.zeros((num_rows, pad_end_len)) 
 
 sig = torch.cat((pad_begin, sig, pad_end), 1) 
 
リターン（sig、sr）

データ拡張: タイムシフト

次に、タイムシフトを適用してオーディオをランダムな量だけ左または右にシフトすることにより、元のオーディオ信号にデータ拡張を実行できます。 この記事では、このデータ拡張手法とその他のデータ拡張手法について詳しく説明します。

 # ----------------------------  
 # 信号を左にシフトします または 右 による 数パーセント。値 最後に​  
 # は「ラップアラウンド」  変換された信号の開始まで。
 # ----------------------------  
 @静的メソッド
def time_shift(aud, shift_limit):
 sig、sr = aud
 _, sig_len = sig.shape
 shift_amt = int (random.random() * shift_limit * sig_len)
戻り値(sig.roll(shift_amt), sr)

メルスペクトログラム

拡張オーディオをメルスペクトログラムに変換します。 これらはオーディオの本質的な特性を捉えており、多くの場合、オーディオ データをディープラーニング モデルに入力する最も適切な方法です。

 # ----------------------------  
 # スペクトログラムを生成する
# ----------------------------  
 @静的メソッド
def spectro_gram(aud, n_mels=64, n_fft=1024, hop_len=なし):
 sig、sr = aud
トップ_db = 80 
 
 # 仕様は [channel, n_mels, time ] の形をしており、 channelはモノラル、ステレオなどです。
 spec = transforms.MelSpectrogram(sr, n_fft=n_fft, hop_length=hop_len, n_mels=n_mels)(sig) 
 
 ＃変換する デシベル​
spec = transforms.AmplitudeToDB(top_db=top_db)(spec)
戻り値(仕様)

データ拡張: 時間と周波数のマスキング

ここで、元のオーディオではなくメル スペクトログラムに対して、もう一度拡張を実行できます。 ここでは、次の 2 つの方法を使用する SpecAugment という手法を使用します。

周波数マスキング - スペクトログラムに水平バーを追加して、連続する周波数の範囲をランダムにマスクします。

時間マスク - 周波数マスクに似ていますが、垂直線を使用してスペクトログラムから時間範囲をランダムにマスクする点が異なります。

 # ----------------------------  
 # スペクトログラムをマスクして拡張する 周波数のいくつかのセクション
# 次元（水平バー）と時間次元（垂直バー）を区別して、
 # 過剰適合と モデルの一般化を向上させるためにマスクされたセクションは
#平均値に置き換えられました。
 # ----------------------------  
 @静的メソッド
定義 spectro_augment(spec、max_mask_pct=0.1、n_freq_masks=1、n_time_masks=1):
 _、n_mels、n_steps = スペックシェイプ
マスク値 = spec.mean()
 aug_spec = スペック
 
 freq_mask_param = 最大マスク率 * n_mels
 _が範囲内(n_freq_masks)の場合:
 aug_spec = transforms.FrequencyMasking(freq_mask_param)(aug_spec, mask_value) 
 
 time_mask_param = max_mask_pct * n_steps
 _が範囲内(n_time_masks)の場合:
 aug_spec = transforms.TimeMasking(time_mask_param)(aug_spec、mask_value) 
 
 aug_specを返す

カスタムデータローダー

前処理変換関数をすべて定義したので、カスタム Pytorch Dataset オブジェクトを定義します。

Pytorch を使用してモデルにデータを供給するには、次の 2 つのオブジェクトが必要です。

すべてのオーディオ変換を使用してオーディオ ファイルを前処理し、一度に 1 つのデータ項目を準備するカスタム Dataset オブジェクト。

Dataset オブジェクトを使用して個々のデータ項目を取得し、それらをデータのバッチにパッケージ化する組み込みの DataLoader オブジェクト。

 torch.utils.dataからDataLoader、Dataset、random_split をインポートします
torchaudio をインポート
 
 # ----------------------------  
 # サウンドデータセット
# ----------------------------  
クラスSoundDS(データセット):
 def __init__(self, df, data_path):
自己.df = df
自己.data_path = str(データパス)
自己持続時間 = 4000
自己.sr = 44100
自己チャンネル = 2
自己シフト率 = 0.4 
 
 # ----------------------------  
 #データセット内のアイテム数
# ----------------------------  
 __len__(自分)を定義します:
 len(self.df)を返す
 
 # ----------------------------  
 #データセット内のi 番目の項目を取得する
# ----------------------------  
 __getitem__(self, idx)を定義します。
 # オーディオファイルの絶対ファイルパス- オーディオディレクトリを  
 #相対パス
audio_file = self.data_path + self.df.loc[idx, 'relative_path' ]
 # クラスIDを取得する
class_id = self.df.loc[idx, 'classID' ] 
 
 aud = AudioUtil.open (オーディオファイル)
 #一部のサウンドは、サンプルレートが高く、チャンネル数が少ないため、
 # 多数派。すべてのサウンドに同じ数のチャンネルと同じ数の
# サンプルレート。サンプルレートが同じでない限り、pad_truncは
#サウンドの長さが同じであっても、異なる長さの配列が生成されます。   
 ＃ 同じ。
 reaud = AudioUtil.resample(aud, self.sr)
 rechan = AudioUtil.rechannel(reaud, self.channel) 
 
 dur_aud = AudioUtil.pad_trunc(rechan, self.duration)
 shift_aud = AudioUtil.time_shift(dur_aud、self.shift_pct) です。
 sgram = AudioUtil.spectro_gram(shift_aud、n_mels=64、n_fft=1024、hop_len=なし)
 aug_sgram = AudioUtil.spectro_augment(sgram、max_mask_pct=0.1、n_freq_masks=2、n_time_masks=2) 
 
 aug_sgram、class_idを返す

データローダーを使用してデータのバッチを準備する

これで、モデルにデータを入力するために必要なすべての関数が定義されました。

カスタム データセットを使用して Pandas から機能とラベルを読み込み、データを 80:20 の比率でトレーニング セットと検証セットにランダムに分割します。 次に、これらを使用してトレーニングおよび検証データ ローダーを作成します。

 torch.utils.dataからrandom_split をインポートします
 
 myds = SoundDS(df, データパス) 
 
 #トレーニングと検証を80:20にランダムに分割
num_items = len(myds)
 num_train = round(num_items * 0.8)
 num_val = num_items - num_train
 train_ds, val_ds = random_split(myds, [num_train, num_val]) 
 
 #トレーニングおよび検証データローダーを作成する
train_dl = torch.utils.data.DataLoader(train_ds、batch_size=16、shuffle= True )
 val_dl = torch.utils.data.DataLoader(val_ds、batch_size=16、shuffle= False )

トレーニングを開始すると、オーディオ ファイル名のリストを含む入力のランダム バッチを取得し、各オーディオ ファイルに対して前処理オーディオ変換を実行します。 また、クラス ID を含む対応するターゲット ラベルのバッチも取得します。 したがって、一度にトレーニング データのバッチが出力され、それをディープラーニング モデルへの入力として直接渡すことができます。

まずオーディオ ファイルから始めて、データ変換の手順を実行してみましょう。

ファイルからのオーディオは Numpy 配列 (numchannels、numsamples) に読み込まれます。オーディオのほとんどは 44.1kHz でサンプリングされ、約 4 秒間続くため、サンプル数は 44,100 * 4 = 176,400 になります。オーディオに 1 つのチャンネルがある場合、配列の形状は (1, 176, 400) になります。同様に、2 チャンネルで 4 秒間持続し、48kHz でサンプリングされたオーディオには、(2, 192,000) の形状を持つ 192,000 個のサンプルが含まれます。

各オーディオのチャンネルとサンプリング レートは異なるため、次の 2 つの変換では、オーディオが標準の 44.1kHz と標準の 2 チャンネルに再サンプリングされます。

一部のオーディオ クリップは 4 秒より長いか短い場合があるため、オーディオの長さも 4 秒の固定長さに正規化します。これで、すべてのアイテムの配列は同じ形状になります (2, 176, 400)

タイムシフト データ拡張は、各オーディオ サンプルをランダムに前方または後方にシフトします。形状は変わりません。

拡張オーディオは、(numchannels, Mel freqbands, time_steps) = (2, 64, 344) の形状を持つメルスペクトログラムに変換されます。

SpecAugment データ拡張関数は、時間と周波数のマスクをメルスペクトログラムにランダムに適用します。形状は変わりません。

最終的にはバッチごとに 2 つのテンソルが作成されます。1 つはメル スペクトログラムを含む X 特徴データ用で、もう 1 つは数値クラス ID を含む y ターゲット ラベル用です。 バッチは、各トレーニング エポックのトレーニング データからランダムに選択されます。

各バッチの形状は (batchsz、numchannels、Mel freqbands、timesteps) です。

バッチ内の 1 つの項目を視覚化できます。 垂直方向と水平方向の縞模様のメル スペクトログラムには、周波数と時間マスクされたデータの拡張が表示されていることがわかります。

モデルの構築

今実行したデータ処理手順は、オーディオ分類の問題の最もユニークな側面です。 ここからのモデルとトレーニング プロセスは、標準的な画像分類問題で一般的に使用されるものと非常に似ており、オーディオ ディープラーニングに固有のものではありません。

データはスペクトログラム画像で構成されているため、それを処理するために CNN 分類アーキテクチャを構築します。 特徴マップを生成する 4 つの畳み込みブロックがあります。 次に、データは必要な形式に再構成され、線形分類レイヤーに入力され、最終的に 10 個のクラスごとに予測が出力されます。

モデル情報:

カラー画像は、(バッチ数、チャネル数、メル周波数バンド、タイムステップ) の形でモデルに入力されます。 （16、2、64、344）。

各 CNN レイヤーはフィルターを適用して、画像の深度、つまりチャネルの数を増やします。 （16、64、4、22）。

これらは結合され、(16, 64) の形状に平坦化されてから、線形レイヤーに送られます。

線形層は各カテゴリの予測スコアを出力する。すなわち、（16, 10）

 torch.nn.function をFとしてインポートします。
 torch.nnからinitをインポート
 
 # ----------------------------  
 # オーディオ分類モデル
# ----------------------------  
クラス AudioClassifier (nn.Module):
 # ----------------------------  
 # モデルアーキテクチャを構築する
# ----------------------------  
 __init__(self)を定義します。
スーパー().__init__()
変換レイヤー = [] 
 
 # Reluとバッチノルムを使用した最初の畳み込みブロック。Kaiming初期化を使用する
self.conv1 = nn.Conv2d(2, 8, カーネルサイズ=(5, 5), ストライド=(2, 2), パディング=(2, 2))
自己.relu1 = nn.ReLU()
自己.bn1 = nn.BatchNorm2d(8)
 init.kaiming_normal_(self.conv1.weight、a=0.1) を使います。
自己.conv1.バイアス.データ.ゼロ_()
 conv_layers += [self.conv1, self.relu1, self.bn1] 
 
 # 2 番目の畳み込みブロック
self.conv2 = nn.Conv2d(8, 16, カーネルサイズ=(3, 3), ストライド=(2, 2), パディング=(1, 1))
自己.relu2 = nn.ReLU()
自己.bn2 = nn.BatchNorm2d(16)
 init.kaiming_normal_(self.conv2.weight、a=0.1) を使います。
自己.conv2.バイアス.データ.ゼロ_()
 conv_layers += [self.conv2、self.relu2、self.bn2] 
 
 # 2 番目の畳み込みブロック
self.conv3 = nn.Conv2d(16, 32, カーネルサイズ=(3, 3), ストライド=(2, 2), パディング=(1, 1))
自己.relu3 = nn.ReLU()
自己.bn3 = nn.BatchNorm2d(32)
 init.kaiming_normal_(self.conv3.weight、a=0.1) を使います。
自己.conv3.バイアス.データ.ゼロ_()
 conv_layers += [self.conv3、self.relu3、self.bn3] 
 
 # 2 番目の畳み込みブロック
self.conv4 = nn.Conv2d(32, 64, カーネルサイズ=(3, 3), ストライド=(2, 2), パディング=(1, 1))
自己.relu4 = nn.ReLU()
自己.bn4 = nn.BatchNorm2d(64)
 init.kaiming_normal_(self.conv4.weight、a=0.1) を使います。
自己.conv4.バイアス.データ.ゼロ_()
 conv_layers += [self.conv4、self.relu4、self.bn4] 
 
 # 線形分類器
自己.ap = nn.AdaptiveAvgPool2d(出力サイズ=1)
 self.lin = nn.Linear(in_features=64、out_features=10) です。 
 
 # 畳み込みブロックをラップする
self.conv = nn.Sequential(*conv_layers) 
 
 # ----------------------------  
 #フォワードパス計算
# ----------------------------  
 def forward (self, x):
 # 畳み込みブロックを実行する
x = 自己変換(x) 
 
 #線形レイヤーへの入力のための適応プールとフラット化
x = 自己.ap(x)
 x = x.view (x.shape[0], -1) 
 
 # 線形レイヤー
x = 自己.lin(x) 
 
 # 最終出力  
 xを返す
 
 #モデルを作成し、可能であれば GPUに配置します
myModel = オーディオ分類器()
デバイス = torch.device( "cuda:0" torch.cuda.is_available() の場合、そうでない場合  "CPU" ）
 myModel = myModel.to (デバイス)
 #確認してください  Cudaについて
次の(myModel.parameters()).device

電車

これで、モデルをトレーニングするためのトレーニング ループを作成する準備が整いました。

トレーニングの進行に合わせて学習率を動的に変更するオプティマイザー、損失関数、学習率スケジュール関数を定義し、モデルの収束を早めます。

各トレーニングラウンドが完了した後。 私たちは、正しい予測の割合を測定する単純な精度メトリックを追跡します。

# ----------------------------

# トレーニングループ

# ----------------------------

def トレーニング(モデル、train_dl、num_epochs):

# 損失関数、オプティマイザー、スケジューラー

基準 = nn.CrossEntropyLoss()

オプティマイザー = torch.optim.Adam(model.parameters(),lr=0.001)

スケジューラ = torch.optim.lr_scheduler.OneCycleLR(オプティマイザ、max_lr=0.001、

ステップ数/エポック = int(len(train_dl))、

エポック=num_epochs、

anneal_strategy = '線形')

# 各エポックごとに繰り返します

範囲(num_epochs)内のエポックの場合:

ランニングロス = 0.0

正しい予測 = 0

合計予測 = 0

# トレーニングセット内の各バッチについて繰り返します

iの場合、enumerate(train_dl)内のデータ:

# 入力特徴とターゲットラベルを取得し、GPUに配置する

入力、ラベル = data[0].to(デバイス)、data[1].to(デバイス)

# 入力を正規化する

inputs_m、inputs_s = inputs.mean()、inputs.std()

入力 = (入力 - inputs_m) / inputs_s

# パラメータの勾配をゼロにする

オプティマイザ.zero_grad()

# 前進 + 後退 + 最適化

出力 = モデル(入力)

損失 = 基準(出力、ラベル)

損失.後方()

オプティマイザ.ステップ()

スケジューラ.ステップ()

# 損失と精度の統計を保存する

実行中の損失 += 損失.item()

# 最高スコアの予測クラスを取得する

_, 予測 = torch.max(出力,1)

# ターゲットラベルに一致した予測の数

正しい予測 += (予測 == ラベル).sum().item()

合計予測 += 予測形状[0]

#if i % 10 == 0: # 10 個のミニバッチごとに印刷

# print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 10))

# エポック終了時に統計情報を出力します

バッチ数 = len(train_dl)

平均損失 = 実行損失 / バッチ数

acc = 正しい予測/合計予測

print(f'エポック: {epoch}, 損失: {avg_loss:.2f}, 精度: {acc:.2f}')

print('トレーニング終了')

num_epochs=2 # デモ用なので、これを高く調整します。

トレーニング(myModel、train_dl、num_epochs)

推論

通常、トレーニング ループの一部として、検証データのメトリックも評価します。 そこで、元のデータから保持されたテスト データセット (トレーニング中に未知のデータとして扱われる) に対して推論を実行します。 このデモでは、検証データを使用します。

勾配更新を無効にして推論ループを実行します。 予測を得るためにモデルでフォワードパスを実行しますが、バックプロパゲーションと最適化は必要ありません。

 # ----------------------------  
 # 推論
# ----------------------------  
 def推論(モデル、val_dl):
正しい予測 = 0
合計予測 = 0 
 
 # グラデーションの更新を無効にする
torch.no_grad()の場合:
 val_dlのデータの場合:
 # 入力特徴とターゲットラベルを取得し、 GPUに配置する
入力、ラベル = data[0] .to (デバイス)、data[1] .to (デバイス) 
 
 # 入力を正規化する
inputs_m、inputs_s = inputs.mean()、inputs.std()
入力 = (入力 - inputs_m) / inputs_s 
 
 # 予測を取得する
出力 = モデル(入力) 
 
 #最高スコアの予測クラスを取得する
_, 予測 = torch.max (出力,1)
 #カウント ターゲットラベルに一致する予測
正しい予測 += (予測 == ラベル) .sum ().item()
合計予測 += 予測形状[0] 
 
 acc = 正しい予測/合計予測
print(f '精度: {acc:.2f}, 合計項目: {total_prediction}' ) 
 
 #検証セットを使用してトレーニング済みモデルで推論を実行する  
推論(myModel、val_dl)

結論は

ここまで、オーディオのディープラーニングにおける最も基本的な問題の 1 つであるサウンド分類のエンドツーエンドの例を見てきました。 これは幅広いアプリケーションで使用できるだけでなく、ここで紹介する概念やテクニックの多くは、人間の音声から始めて、人が言っていることを理解し、それをテキストに変換する自動音声認識などの、より複雑なオーディオの問題にも関連します。