RNN 기반 생성 모델을 가사와 피아노 음악 생성에 적용한 사례를 보여주는 게시물입니다.
소개
이 게시물에서는 가장 인기 있는/최근 아티스트의 가사 데이터 세트에서 RNN 문자 수준 언어 모델을 학습합니다. 학습된 모델을 가지고 다양한 아티스트의 다양한 스타일을 재밌게 섞은 몇 곡을 샘플링합니다. 그런 다음 모델을 업데이트하여 조건부 문자 수준 RNN으로 만들어 아티스트에 따라 노래를 샘플링할 수 있습니다. 마지막으로 피아노 곡의 미디 데이터 세트에서 모델을 학습하여 마무리합니다. 이러한 모든 작업을 해결하는 동안 문자 수준 RNN, 조건부 문자 수준 RNN, RNN 샘플링, 시간에 따른 절단된 역전파 및 그래디언트 체크포인팅과 같은 RNN 학습 및 추론과 관련된 몇 가지 흥미로운 개념을 간략하게 살펴보겠습니다. 모든 코드와 학습된 모델은 github에서 사용할 수 있으며 Pytorch 로 구현되었습니다 . 블로그 게시물은 jupyter notebook 형식으로도 볼 수 있습니다 . 문자 수준 언어 모델과 순환 신경망에 익숙하다면 해당 섹션을 건너뛰거나 결과 섹션으로 바로 이동하세요.
문자 수준 언어 모델
모델을 선택하기 전에, 우리의 과제를 자세히 살펴보겠습니다. 현재 문자와 이전의 모든 문자가 주어졌을 때, 우리는 다음 문자를 예측해 볼 것입니다. 훈련하는 동안 우리는 시퀀스를 취하고, 마지막 문자를 제외한 모든 문자를 입력으로 사용하고, 두 번째 문자에서 시작하는 동일한 시퀀스를 기준 진실로 사용할 것입니다(위의 그림 참조; 출처 ). 우리는 예측을 할 때 이전의 모든 문자를 무시하는 가장 간단한 모델에서 시작하여, 이 모델을 개선하여 특정 수의 이전 문자만 고려하도록 하고, 예측을 할 때 이전의 모든 문자를 고려하는 모델로 결론지을 것입니다.
우리의 언어 모델은 문자 수준에서 정의됩니다. 우리는 모든 영어 문자와 마침표, 쉼표, 줄 끝 기호와 같은 일부 특수 기호를 포함하는 사전을 만들 것입니다. 각 문자는 one-hot-encoded 텐서로 표현됩니다. 문자 수준 모델과 예제에 대한 자세한 내용은 이 리소스를 추천합니다 .
문자를 가지고 있으므로 이제 문자 시퀀스를 형성할 수 있습니다. 지금도 고정된 확률로 문자를 무작위로 샘플링하여 문장을 생성할 수 있습니다 . 이것이 가장 간단한 문자 수준 언어 모델입니다. 이것보다 더 나은 방법은 없을까요? 그렇습니다. 훈련 코퍼스에서 각 문자의 발생 확률(문자가 발생하는 횟수를 데이터 세트 크기로 나눈 값)을 계산하고 이러한 확률을 사용하여 문자를 무작위로 샘플링할 수 있습니다. 이 모델은 더 좋지만 각 문자의 상대적인 위치적 측면을 완전히 무시합니다. 예를 들어, 단어를 읽는 방법에 주의하세요. 첫 번째 문자부터 시작하는데, 이는 일반적으로 예측하기 어렵지만 단어의 끝에 도달하면 때때로 다음 문자를 추측할 수 있습니다. 단어를 읽을 때 다른 텍스트를 읽고 배운 일부 규칙을 암묵적으로 사용하고 있습니다. 예를 들어, 단어에서 읽는 문자가 하나 더 추가될 때마다 공백 문자의 확률이 증가하거나(정말 긴 단어는 드뭅니다) 문자 “r” 뒤에 자음이 올 확률은 일반적으로 모음 뒤에 오기 때문에 낮습니다. 비슷한 규칙이 많이 있고, 우리 모델이 데이터로부터 이를 학습할 수 있기를 바랍니다. 우리 모델이 이러한 규칙을 학습할 수 있는 기회를 주기 위해 모델을 확장해야 합니다.
모델을 조금씩 점진적으로 개선하고 각 문자의 확률을 이전에 발생한 문자에만 의존하도록 합시다( 마르코프 가정 ). 따라서 기본적으로 . 이것은 마르코프 연쇄 모델 입니다( 익숙하지 않다면 이러한 대화형 시각화 도 시도해 보세요). 또한 훈련 데이터 세트에서 확률 분포를 추정할 수 있습니다. 이 모델은 대부분의 경우 현재 문자의 확률이 이전 문자에만 의존하지 않기 때문에 제한적입니다.
우리가 모델링하고자 하는 것은 실제로 . 처음에는 이전 문자의 수가 가변적이고 긴 시퀀스의 경우 정말 커질 수 있기 때문에 작업이 난해해 보입니다. Reccurent Neural Netoworks는 공유 가중치와 고정 크기 숨겨진 상태를 사용하여 어느 정도 이 문제를 해결할 수 있는 것으로 밝혀졌습니다. 이는 RNN에 전념하는 다음 섹션으로 이어집니다.
순환 신경망
순환 신경망은 순차적 데이터를 처리하기 위한 신경망 계열입니다. 피드포워드 신경망과 달리 RNN은 내부 메모리를 사용하여 임의의 입력 시퀀스를 처리할 수 있습니다. 임의의 크기의 입력 시퀀스로 인해 사이클이 있는 그래프로 간결하게 표현됩니다(그림 참조; 출처 ). 하지만 입력 시퀀스의 크기를 알면 “펼쳐질” 수 있습니다. 현재 입력 과 이전 숨겨진 상태 에서 출력 과 현재 숨겨진 상태 로의 비선형 매핑을 정의합니다 . 숨겨진 상태 크기는 미리 정의된 크기를 가지며 각 단계에서 업데이트되고 매핑 결과에 영향을 미치는 기능을 저장합니다.
이제 문자 수준 언어 모델의 이전 그림과 접힌 RNN 그림을 맞춰서 RNN 모델을 사용하여 문자 수준 언어 모델을 어떻게 학습하는지 살펴보겠습니다.
그림에서는 Vanilla RNN을 사용하고 있지만, 우리의 작업에서는 LSTM을 사용할 것입니다. 왜냐하면 훈련이 더 쉽고 보통 더 나은 결과를 얻을 수 있기 때문입니다.
RNN에 대한 더 자세한 소개는 다음 자료 를 참조하세요 .
가사 데이터 세트
실험을 위해 우리는 다양한 최신 아티스트와 더 오래된 아티스트를 포함하는 55,000개 이상의 노래 가사 Kaggle 데이터 세트를 선택했습니다 . 이는 판다스 파일로 저장되며, 훈련 목적으로 사용할 수 있도록 파이썬 래퍼를 작성했습니다. 코드를 사용하려면 직접 다운로드해야 합니다.
결과를 더 잘 해석하기 위해, 나는 내가 어느 정도 알고 있는 아티스트 하위 집합을 선택했습니다.
artists = [
'ABBA',
'Ace Of Base',
'Aerosmith',
'Avril Lavigne',
'Backstreet Boys',
'Bob Marley',
'Bon Jovi',
'Britney Spears',
'Bruno Mars',
'Coldplay',
'Def Leppard',
'Depeche Mode',
'Ed Sheeran',
'Elton John',
'Elvis Presley',
'Eminem',
'Enrique Iglesias',
'Evanescence',
'Fall Out Boy',
'Foo Fighters',
'Green Day',
'HIM',
'Imagine Dragons',
'Incubus',
'Jimi Hendrix',
'Justin Bieber',
'Justin Timberlake',
'Kanye West',
'Katy Perry',
'The Killers',
'Kiss',
'Lady Gaga',
'Lana Del Rey',
'Linkin Park',
'Madonna',
'Marilyn Manson',
'Maroon 5',
'Metallica',
'Michael Bolton',
'Michael Jackson',
'Miley Cyrus',
'Nickelback',
'Nightwish',
'Nirvana',
'Oasis',
'Offspring',
'One Direction',
'Ozzy Osbourne',
'P!nk',
'Queen',
'Radiohead',
'Red Hot Chili Peppers',
'Rihanna',
'Robbie Williams',
'Rolling Stones',
'Roxette',
'Scorpions',
'Snoop Dogg',
'Sting',
'The Script',
'U2',
'Weezer',
'Yellowcard',
'ZZ Top']
무조건 문자 수준 언어 모델 훈련
우리의 첫 번째 실험은 전체 코퍼스에서 문자 수준 언어 모델 RNN을 훈련하는 것으로 구성되었습니다. 훈련하는 동안 아티스트 정보는 고려하지 않았습니다.
RNN에서 샘플링
모델을 훈련한 후 몇 곡을 샘플링해 보겠습니다. 기본적으로 RNN은 각 단계에서 로짓을 출력하고 이를 소프트맥스하여 해당 분포에서 샘플링할 수 있습니다. 또는 Gumble-Max 트릭을 사용하여 로짓을 직접 샘플링 할 수도 있는데 이는 동일합니다.
샘플링에 대한 흥미로운 점 하나는 우리가 입력 시퀀스를 부분적으로 스스로 정의하고 그 초기 조건으로 샘플링을 시작할 수 있다는 것입니다. 예를 들어, “Why”로 시작하는 노래를 샘플링할 수 있습니다.
Why do you have to leave me?
I think I know I'm not the only one
I don't know if I'm gonna stay awake
I don't know why I go along
I don't know why I can't go on
I don't know why I don't know
I don't know why I don't know
I don't know why I keep on dreaming of you
음, 그럴 법한 노래네요 😀
“Well”로 시작하는 노래로 샘플링해 보겠습니다.
Well, I was a real good time
I was a rolling stone
I was a rock and roller
Well, I never had a rock and roll
There were times I had to do it
I had a feeling that I was found
I was the one who had to go
샘플링 중에 사용되는 “온도” 매개변수가 있는데, 이는 샘플링 프로세스의 무작위성을 제어합니다. 이 매개변수가 0에 가까워지면 샘플링은 argmax와 동일하고 무한대에 가까워지면 샘플링은 균일한 분포에서 샘플링하는 것과 동일합니다. Jang et al.의 관련 논문 에서 그림을 살펴보세요 .
, 분포는 영향을 받지 않습니다. 를 감소시키면 분포가 더 두드러지게 되며, 이는 더 큰 확률 질량을 가진 값이 증가한다는 것을 의미합니다. 를 0에 가까워지면 샘플링 은 armax와 동일해지므로 해당 값의 확률이 1에 가까워집니다. 를 증가시키기 시작하면 분포가 점점 더 균일해집니다.
이전 샘플은 온도 매개변수가 . 와 같도록 생성되었습니다. . 로 늘리면 어떻게 되는지 살펴보겠습니다 . 샘플:
Why can't we drop out of time?
We were born for words to see.
Won't you love this. You're still so amazing.
This could be that down on Sunday Time.
Oh, Caroline, a lady floor.
I thought of love, oh baby.
좀더 늘려보도록 하죠.
Why - won't we grow up naked?
We went quietly what we would've still give
That girl you walked before our bedroom room
I see your mind is so small to a freak
Stretching for a cold white-heart of crashing
Truth in the universal daughter
I lose more and more hard
I love you anytime at all
Ah come let your help remind me
Now I've wanted waste and never noticed
I swear I saw you today
You needed to get by
But you sold a hurricane
Well out whispered in store
사실, 왜 우리는 벌거벗고 자라지 않을까요? 😀 온도가 높아질수록 샘플링된 문장이 점점 더 무작위적이 되는 추세를 볼 수 있죠.
조건부 문자 수준 언어 모델 훈련
특정 아티스트의 스타일로 가사를 생성할 수 있다고 상상해보세요. 모델을 변경하여 훈련 중에 이 정보를 사용할 수 있도록 합시다.
우리는 RNN에 추가 입력을 추가하여 이를 수행할 것입니다. 지금까지 우리의 RNN 모델은 각 단계에서 원핫 인코딩된 문자가 포함된 텐서만 허용했습니다.
우리 모델의 확장은 매우 간단할 것입니다. 아티스트를 나타내는 추가 원핫 인코딩 텐서가 있을 것입니다. 따라서 각 단계에서 RNN은 캐릭터와 아티스트를 나타내는 연결된 텐서로 구성되는 텐서 하나를 허용합니다. 자세한 내용은 여기를 참조하세요 .
조건 언어 모델 RNN에서 샘플링
훈련 후, 우리는 아티스트에 따라 몇 곡을 샘플링했습니다. 아래에서 몇 가지 결과를 찾을 수 있습니다.
그를:
My fears
And the moment don't make me sing
So free from you
The pain you love me yeah
Whatever caused the warmth
You smile you're happy
You sit away
You say it's all in vain
실제로 가능해 보이는데, 특히 ‘고통’이라는 단어가 사용됐기 때문입니다. 이 단어는 아티스트의 가사에서 매우 흔하게 쓰입니다.
아바:
Oh, my love it makes me close a thing
You've been heard, I must have waited
I hear you
So I say
Thank you for the music, that makes me cry
And you moving my bad as me, ah-hang wind in the hell
I was meant to be with you, I'll never be playing up
밥 말리:
Mercy on judgment, we got so much
Alcohol, cry, cry, cry
Why don't try to find our own
I want to know, Lord, I wanna give you
Just saving it, learned
Is there any more?
All that damage done
That's all reason, don't worry
Need a hammer
I need you more and more
콜드플레이:
Look at the stars
Into life matter where you lay
Saying no doubt
I don't want to fly
In my dreams and fight today
I will fall for you
All I know
And I want you to stay
Into the night
I want to live waiting
With my love and always
Have I wouldn't wasted
Would it hurt you
카니예 웨스트:
I'm everywhere for you
The way that it couldn't stop
I mean it too late and love I made in the world
I told you so I took the studs full cold-stop
The hardest stressed growin'
The hustler raisin' on my tears
I know I'm true, one of your love
꽤 멋져 보이지만 검증 정확도를 추적하지 않았기 때문에 일부 샘플링된 라인은 rnn에서 기억했을 수도 있다는 점을 명심하세요.더 나은 방법은 훈련 중에 가장 좋은 검증 점수를 제공하는 모델을 선택하는 것입니다(이런 방식으로 훈련을 수행한 다음 섹션의 코드 참조).또한 흥미로운 사실 하나를 발견했습니다.무조건 모델은 일반적으로 지정된 시작 문자열로 샘플링할 때 더 나은 성능을 보입니다.지정된 시작 문자열로 조건부 모델에서 샘플링할 때 실제로 모델에 두 가지 조건(시작 문자열과 아티스트)을 적용한 반면, 이전에 탐색한 모델의 경우 하나의 조건만 적용했습니다.그리고 그 조건부 분포를 잘 모델링할 만큼 충분한 데이터가 없었습니다(모든 아티스트가 비교적 제한된 수의 노래를 가지고 있음).
우리는 코드와 모델을 공개하고 있으며, GPU 없이도 훈련된 모델에서 노래를 샘플링할 수 있습니다. 이는 실제로 컴퓨팅 측면에서 많은 요구가 없기 때문입니다.
미디 데이터 세트
다음으로, 우리는 대략 피아노 곡으로 구성된 작은 미디 데이터세트 로 작업할 것입니다 . 우리는 피아노 데이터세트(트레이닝 분할만)를 사용했습니다 .Nottingam
모든 미디 파일을 피아노 롤로 변환 할 수 있다는 것이 밝혀졌습니다. 피아노 롤은 각 행이 다른 미디 피치이고 각 열이 시간적으로 다른 슬라이스인 시간-주파수 행렬입니다. 따라서 데이터 세트의 각 피아노 곡은 크기의 행렬로 표현되며 , 여기서 는 피아노의 피치 수입니다. 피아노 롤 행렬의 예는 다음과 같습니다.
이 표현은 음악 이론에 익숙하지 않은 사람이라도 매우 직관적이고 해석하기 쉽습니다. 각 행은 피치를 나타냅니다. 위쪽 행은 저주파 피치를 나타내고 아래쪽 행은 고주파 피치를 나타냅니다. 게다가 시간을 나타내는 수평축이 있습니다. 따라서 특정 피치의 사운드를 특정 시간 동안 연주하면 수평선이 표시됩니다. 전반적으로 이는 유튜브의 피아노 튜토리얼 과 매우 유사합니다 .
이제 문자 수준 모델과 새로운 작업의 유사점을 살펴보겠습니다. 현재의 경우 이전에 연주된 모든 피치를 고려하여 다음 타임스텝에서 연주될 피치를 예측해야 합니다. 피아노 롤 그림을 보면 각 열은 어떤 종류의 음악적 캐릭터를 나타내며 이전의 모든 음악적 캐릭터를 고려하여 다음 음악을 예측하려고 합니다. 텍스트 문자와 음악적 캐릭터의 차이점에 주의해 보겠습니다. 기억하시겠지만 언어 모델의 각 캐릭터는 원핫 벡터로 표현되었습니다(즉, 벡터에서 하나의 값만 이고 다른 값은 입니다 ). 음악적 캐릭터의 경우 한 타임스텝에서 여러 키를 누를 수 있습니다(다성음 데이터 세트로 작업하고 있기 때문입니다). 이 경우 각 타임스텝은 두 개 이상의 를 포함할 수 있는 벡터로 표현됩니다 .
피치 레벨 피아노 음악 모델 훈련
학습을 시작하기 전에, 이전 섹션에서 논의한 다양한 입력을 설명하기 위해 언어 모델에 사용한 손실을 조정해야 합니다. 언어 모델에서, 각 타임스텝에 대한 입력으로 원-핫 인코딩된 텐서(문자)를 사용했고, 출력(예측된 다음 문자)으로 원-핫 인코딩된 텐서를 사용했습니다. 예측된 다음 문자에 대해 단일 배타적 선택을 해야 했기 때문에, 교차 엔트로피 손실을 사용했습니다 .
하지만 이제 우리 모델은 더 이상 원핫 인코딩(여러 키를 누를 수 있음)이 아닌 벡터를 출력합니다. 물론, 눌린 키의 모든 가능한 조합을 별도의 클래스로 처리할 수 있지만, 이는 어렵습니다. 대신 출력 벡터의 각 요소를 이진 변수( – 누름, – 키를 누르지 않음)로 처리합니다. 출력 벡터의 각 요소에 대한 별도의 손실을 이진 교차 엔트로피로 정의합니다. 그리고 최종 손실은 이러한 이진 교차 엔트로피의 평균 합계가 됩니다. 더 잘 이해하기 위해 코드를 읽을 수도 있습니다.
앞서 언급한 변경 사항을 적용한 후, 우리는 모델을 훈련했습니다. 다음 섹션에서는 샘플링을 수행하고 결과를 검사합니다.
피치 레벨 RNN에서 샘플링
우리는 최적화 초기 단계에서 피아노 롤을 샘플링했습니다.
우리 모델이 데이터 세트의 노래에서 공통적으로 나타나는 하나의 공통 패턴을 학습하기 시작한 것을 볼 수 있습니다. 각 노래는 두 개의 다른 부분으로 구성되어 있습니다. 첫 번째 부분에는 별도로 연주되고 매우 구별되며 종종 부를 수 있는 피치 시퀀스가 포함되어 있습니다 (멜로디라고도 함). 샘플링된 피아노 롤을 보면 이 부분이 하단에서 명확하게 보입니다. 피아노 롤의 상단도 보면 일반적으로 함께 연주되는 피치 그룹이 보입니다. 이것은 멜로디를 동반하는 화음(노래 전체에서 함께 연주되는 피치)의 진행 또는 하모니입니다.
훈련이 끝날 무렵 우리 모델에서 추출한 샘플은 다음과 같이 보이기 시작했습니다.
보시다시피 이는 이전 섹션에서 보여드린 실제 피아노 롤 사진과 더욱 유사해 보이기 시작했습니다.
훈련 후, 우리는 노래를 샘플링하고 분석했습니다. 흥미로운 소개가 있는 샘플 하나를 얻었습니다 . 다른 샘플은 멋진 스타일 전환을 특징으로 합니다 . 동시에 낮은 온도 매개변수를 가진 몇 가지 예를 생성하여 느린 템포의 노래를 만들었습니다. 첫 번째 와 두 번째는 여기 있습니다 . 전체 재생 목록은 여기 에서 찾을 수 있습니다 .
이제 GPU 메모리 소비와 속도 관점에서 문제를 살펴보겠습니다.
우리는 배치로 시퀀스를 처리함으로써 계산 속도를 크게 높였습니다. 동시에, 시퀀스가 길어질수록(데이터 세트에 따라 다름) 최대 배치 크기가 감소하기 시작합니다. 왜 그럴까요? 역전파를 사용하여 기울기를 계산할 때, 메모리 소비에 가장 큰 영향을 미치는 모든 중간 활동을 저장해야 합니다. 시퀀스가 길어질수록 더 많은 활성화를 저장해야 하므로 배치에 더 적은 예제를 넣을 수 있습니다.
때로는 정말 긴 시퀀스로 작업해야 하거나 배치 크기를 늘리거나, 아니면 사용 가능한 메모리 양이 적은 GPU가 필요할 수도 있습니다. 이 경우 메모리 소모를 줄이는 여러 가지 가능한 솔루션이 있지만, 서로 다른 상충 관계가 있는 두 가지를 언급하겠습니다.
첫 번째는 잘린 역전파 입니다 . 아이디어는 전체 시퀀스를 하위 시퀀스로 분할하고 이를 별도의 배치로 처리하는 것입니다. 단, 이러한 배치를 분할 순서대로 처리하고 모든 다음 배치는 이전 배치의 숨겨진 상태를 초기 숨겨진 상태로 사용합니다. 또한 이 접근 방식의 구현을 제공하여 더 잘 이해할 수 있도록 합니다. 이 접근 방식은 분명히 전체 시퀀스를 처리하는 것과 정확히 동일하지는 않지만 더 자주 업데이트하고 메모리를 덜 사용합니다. 반면에 한 하위 시퀀스의 길이를 넘어서는 장기 종속성을 포착하지 못할 가능성이 있습니다.
두 번째는 그래디언트 체크포인팅 입니다 . 이 방법은 더 많은 계산을 수행하는 대가로 전체 시퀀스에서 모델을 학습하는 동안 더 적은 메모리를 사용할 수 있는 가능성을 제공합니다. 기억하시겠지만, 이전에 학습하는 동안 가장 많은 메모리가 활성화에 의해 차지된다고 언급했습니다. 그래디언트 체크포인팅의 아이디어는 모든 -번째 활성화만 저장하고 나중에 저장되지 않은 활성화를 다시 계산하는 것입니다. 이 방법은 이미 Tensorflow에 구현되어 있으며 Pytorch에 구현되고 있습니다 .
결론 및 향후 작업
저희의 작업에서는 텍스트에 대한 간단한 생성 모델을 훈련하고, 다성음악에 맞춰 모델을 확장했으며, 샘플링이 작동하는 방식과 온도 매개변수가 텍스트와 음악 샘플에 어떤 영향을 미치는지 간략히 살펴보았습니다. 낮은 온도는 더 안정적인 결과를 제공하는 반면, 높은 온도는 더 많은 무작위성을 추가하여 때로는 매우 흥미로운 샘플이 생성됩니다.
향후 작업에는 두 가지 방향이 포함될 수 있습니다. 더 많은 응용 프로그램 또는 이미 훈련된 모델에 대한 심층 분석입니다. 예를 들어 동일한 모델을 Spotify 청취 기록에 적용할 수 있습니다. 청취 기록 데이터에 대한 학습이 끝나면 이전 1시간 정도 동안 들었던 노래 시퀀스를 제공하면 하루 종일 재생 목록을 샘플링합니다. 탐색 기록에도 동일한 작업을 수행할 수 있으며, 탐색 행동 패턴을 분석하는 멋진 도구가 됩니다. 다양한 활동(헬스장에서 운동, 사무실에서 일하기, 수면)을 수행하는 동안 휴대폰에서 가속도계 및 자이로스코프 데이터를 수집 하고 이러한 활동 단계를 분류하는 방법을 학습합니다. 그런 다음 활동에 따라 음악 재생 목록을 자동으로 변경할 수 있습니다(수면 – 비 오는 차분한 음악, 헬스장에서 운동 – 고강도 음악). 의료 응용 프로그램의 경우 이 작업 과 유사하게 모델을 적용하여 맥박 및 기타 데이터를 기반으로 심장 문제를 감지할 수 있습니다 .
음악 생성을 위해 훈련된 RNN에서 뉴런 발화를 분석하는 것은 매우 흥미로울 것입니다 . 모델이 몇 가지 간단한 음악 개념(화성과 멜로디에 대한 논의와 같은)을 암묵적으로 배웠는지 확인하기 위해서입니다. RNN의 숨겨진 표현을 사용하여 음악 데이터 세트를 클러스터링하여 유사한 노래를 찾을 수 있습니다.
이 글을 마무리하기 위해 무조건 모델의 마지막 가사를 샘플링해 보겠습니다 😀 :
The story ends
The sound of the blue
The tears were shining
The story of my life
I still believe
The story of my life
[출처] https://warmspringwinds.github.io/pytorch/rnns/2018/01/27/learning-to-generate-lyrics-and-music-with-recurrent-neural-networks/
A post showing an application of RNN-based generative models for lyrics and piano music generation.
Introduction
In this post we will train RNN character-level language model on lyrics dataset of most popular/recent artists. Having a trained model, we will sample a couple of songs which will be a funny mixture of different styles of different artists. After that we will update our model to become a conditional character-level RNN, making it possible for us to sample songs conditioned on artist. And finally, we conclude by training our model on midi dataset of piano songs. While solving all these tasks, we will briefly explore some interesting concepts related to RNN training and inference like character-level RNN, conditional character-level RNN, sampling from RNN, truncated backpropagation through time and gradient checkpointing. All the code and trained models are available on github and were implemented in Pytorch. The blog post can also be viewed in a jupyter notebook format. If you are already familiar with the character-level language model and recurrent neural networks, feel free to skip respective sections or go directly to the results section.
Character-Level language model
Before choosing a model, let’s have a closer look at our task. Given current letter and all previous letters, we will try to predict the next character. During training we will just take a sequence, and use all its characters except the last one as an input and the same sequence starting from the second character as groundtruth (see the picture above; Source). We will start from the simplest model that ignores all the previous characters while making a prediction, improve this model to make it take only a certain number of previous characters into account, and conclude with a model that takes all the previous characters into consideration while making a prediction.
Our language model is defined on a character level. We will create a dictionary which will contain all English characters plus some special symbols, like period, comma, and end-of-line symbol. Each charecter will be represented as one-hot-encoded tensor. For more information about character-level models and examples, I recommend this resource.
Having characters, we can now form sequences of characters. We can generate sentences even now just by randomly sampling character after character with a fixed probability . That’s the most simple character level language model. Can we do better than this? Yes, we can compute the probabily of occurance of each letter from our training corpus (number of times a letter occures divided by the size of our dataset) and randomly sample letter using these probabilities. This model is better but it totally ignores the relative positional aspect of each letter. For example, pay attention on how you read any word: you start with the first letter, which is usually hard to predict, but as you reach the end of a word you can sometimes guess the next letter. When you read any word you are implicitly using some rules which you learned by reading other texts: for example, with each additional letter that you read from a word, the probability of a space character increases (really long words are rare) or the probability of any consonant after the letter “r” is low as it usually followed by vowel. There are lot of similar rules and we hope that our model will be able to learn them from data. To give our model a chance to learn these rules we need to extend it.
Let’s make a small gradual improvement of our model and let probability of each letter depend only on the previously occured letter (markov assumption). So, basically we will have . This is a Markov chain model (also try these interactive visualizations if you are not familiar with it). We can also estimate the probability distribution from our training dataset. This model is limited because in most cases the probability of the current letter depends not only on the previous letter.
What we would like to model is actually . At first, the task seems intractable as the number of previous letters is variable and it might become really large in case of long sequences. Turns out Reccurent Neural Netoworks can tackle this problem to a certain extent by using shared weights and fixed size hidden state. This leads us to a next section dedicated to RNNs.
Recurrent Neural Networks
Recurrent neural networks are a family of neural networks for processing sequential data. Unlike feedforward neural networks, RNNs can use their internal memory to process arbitrary sequences of inputs. Because of arbitrary size input sequences, they are concisely depicted as a graph with a cycle (see the picture; Source). But they can be “unfolded” if the size of input sequence is known. They define a non-linear mapping from a current input and previous hidden state to the output and current hidden state . Hidden state size has a predefined size and stores features which are updated on each step and affect the result of mapping.
Now align the previous picture of the character-level language model and the ufolded RNN picture to see how we are using the RNN model to learn a character level language model.
While the picture depicts the Vanilla RNN, we will use LSTM in our work as it is easier to train usually achieves better results.
For a more elaborate introduction to RNNs, we refer reader to the following resource.
Lyrics dataset
For our experiments we have chosen 55000+ Song Lyrics Kaggle dataset which contains good variety of recent artists and more older ones. It is stored as a pandas file and we wrote a python wrapper around it to be able to use it for training purposes. You will have to download it yourself in order to be able to use our code.
In order to be able to interpret the results better, I have chosen a subset of artists which I am more or less familiar with:
artists = [
'ABBA',
'Ace Of Base',
'Aerosmith',
'Avril Lavigne',
'Backstreet Boys',
'Bob Marley',
'Bon Jovi',
'Britney Spears',
'Bruno Mars',
'Coldplay',
'Def Leppard',
'Depeche Mode',
'Ed Sheeran',
'Elton John',
'Elvis Presley',
'Eminem',
'Enrique Iglesias',
'Evanescence',
'Fall Out Boy',
'Foo Fighters',
'Green Day',
'HIM',
'Imagine Dragons',
'Incubus',
'Jimi Hendrix',
'Justin Bieber',
'Justin Timberlake',
'Kanye West',
'Katy Perry',
'The Killers',
'Kiss',
'Lady Gaga',
'Lana Del Rey',
'Linkin Park',
'Madonna',
'Marilyn Manson',
'Maroon 5',
'Metallica',
'Michael Bolton',
'Michael Jackson',
'Miley Cyrus',
'Nickelback',
'Nightwish',
'Nirvana',
'Oasis',
'Offspring',
'One Direction',
'Ozzy Osbourne',
'P!nk',
'Queen',
'Radiohead',
'Red Hot Chili Peppers',
'Rihanna',
'Robbie Williams',
'Rolling Stones',
'Roxette',
'Scorpions',
'Snoop Dogg',
'Sting',
'The Script',
'U2',
'Weezer',
'Yellowcard',
'ZZ Top']
Training unconditional character-level language model
Our first experiment consisted of training of our character-level language model RNN on the whole corpus. We didn’t take into consideration the artist information while training.
Sampling from RNN
Let’s try to sample a couple of songs after training our model. Basically, on each step our RNN will output logits and we can softmax them and sample from that distribution. Or we can use Gumble-Max trick and sample using logits directly which is equivalent.
One intersting thing about sampling is that we can partially define the input sequence ourselves and start sampling with that initial condition. For example, we can sample a song that starts with “Why”:
Why do you have to leave me?
I think I know I'm not the only one
I don't know if I'm gonna stay awake
I don't know why I go along
I don't know why I can't go on
I don't know why I don't know
I don't know why I don't know
I don't know why I keep on dreaming of you
Well, that sounds like a possible song 😀
Let’s sample with a song that starts with “Well”:
Well, I was a real good time
I was a rolling stone
I was a rock and roller
Well, I never had a rock and roll
There were times I had to do it
I had a feeling that I was found
I was the one who had to go
There is “temperature” parameter that is used during sampling which controls the randomness of sampling process. When this parameter approaches zero, the sampling is equivalent to argmax and when it is close to infinity the sampling is equivalent to sampling from a uniform distribution. Have a look at the figure from a relevant paper by Jang et al.:
When , the distribution is not affected. If we decrease , the distribution becomes more pronounced, meaning that value with bigger probability mass will have it increased. When will approach zero, sampling will be equivalent to armax, because the probability of that value will be close to one. When we start to icrease the distribution becomes more and more uniform.
The previous sample was generated with a temperature paramter equal to . Let’s see what happens when we increase it to and sample:
Why can't we drop out of time?
We were born for words to see.
Won't you love this. You're still so amazing.
This could be that down on Sunday Time.
Oh, Caroline, a lady floor.
I thought of love, oh baby.
Let’s try increasing it even more:
Why - won't we grow up naked?
We went quietly what we would've still give
That girl you walked before our bedroom room
I see your mind is so small to a freak
Stretching for a cold white-heart of crashing
Truth in the universal daughter
I lose more and more hard
I love you anytime at all
Ah come let your help remind me
Now I've wanted waste and never noticed
I swear I saw you today
You needed to get by
But you sold a hurricane
Well out whispered in store
Why don’t we grow up naked, indeed? 😀 Well, you can see that trend that when we increase the temperature, sampled sentences become more and more random.
Training conditional character-level language model
Imagine if we could generate lyrics in a style of some particular artist. Let’s change our model, so that it can use this information during training.
We will do this by adding an additional input to our RNN. So far, our RNN model was only accepting tensors containing one-hot encoded character on each step.
The extention to our model will be very simple: we will have and additional one-hot encoded tensor which will represent the artist. So on each step the RNN will accept one tensor which will consist of concatenated tensors representing character and artist. Look here for more.
Sampling from conditional language model RNN
After training, we sampled a couple of songs conditined on artist. Below you can find some results.
Him:
My fears
And the moment don't make me sing
So free from you
The pain you love me yeah
Whatever caused the warmth
You smile you're happy
You sit away
You say it's all in vain
Seems really possible, especially the fact the the word pain was used, which is very common in the lyrics of the artist.
ABBA:
Oh, my love it makes me close a thing
You've been heard, I must have waited
I hear you
So I say
Thank you for the music, that makes me cry
And you moving my bad as me, ah-hang wind in the hell
I was meant to be with you, I'll never be playing up
Bob Marley:
Mercy on judgment, we got so much
Alcohol, cry, cry, cry
Why don't try to find our own
I want to know, Lord, I wanna give you
Just saving it, learned
Is there any more?
All that damage done
That's all reason, don't worry
Need a hammer
I need you more and more
Coldplay:
Look at the stars
Into life matter where you lay
Saying no doubt
I don't want to fly
In my dreams and fight today
I will fall for you
All I know
And I want you to stay
Into the night
I want to live waiting
With my love and always
Have I wouldn't wasted
Would it hurt you
Kanye West:
I'm everywhere for you
The way that it couldn't stop
I mean it too late and love I made in the world
I told you so I took the studs full cold-stop
The hardest stressed growin'
The hustler raisin' on my tears
I know I'm true, one of your love
Looks pretty cool but keep in mind that we didn’t track the validation accuracy so some sampled lines could have been just memorized by our rnn. A better way to do it is to pick a model that gives best validation score during training (see the code for the next section where we performed training this way). We also noticed one interesting thing: the unconditional model usually performes better when you want to sample with a specified starting string. Our intuition is that when sampling from a conditional model with a specified starting string, we actually put two conditions on our model – starting string and an artist compared to the one condition in the case of previous model that we explored. And we didn’t have enough data to model that conditional distribution well (every artist has relatively limited number of songs).
We are making the code and models available and you can sample songs from our trained models even without gpu as it is not really computationally demanding.
Midi dataset
Next, we will work with a small midi dataset consisting of approximately piano songs. We have used the Nottingam piano dataset (training split only).
Turns out that any midi file can be converted to piano roll which is just is a time-frequency matrix where each row is a different MIDI pitch and each column is a different slice in time. So each piano song from our dataset will be represented as a matrix of size , where is a number of pitches of the piano. Here is an example of piano roll matrix:
This representation is very intuitive and easy to interpret even for a person that is not familiar with music theory. Each row represents a pitch: top rows represent low frequency pitches and bottom rows represent high pitches. Plus, we have a horizontal axis which represents time. So if we play a sound with a certain pitch for a certian period of time, we will see a horizontal line. Overall, this is very similar to piano tutorials on youtube.
Now, let’s try to see the similarities between the character-level model and our new task. In the current case, we will have to predict the pitches that will be played on the next timestep, given all the previously played pitches. So, if you look at the picture of the piano roll, each column represents some kind of a musical character and given all the previous musical characters, we want to predict the next one. Let’s pay attention to the difference between a text character and a musical character. If you recall, each character in our language model was represented by one-hot vector (meaning that only one value in our vector is and others are ). For music character multiple keys can be pressed at one timestep (since we are working with polyphonic dataset). In this case, each timestep will be represented by a vector which can contain more than one .
Training pitch-level piano music model
Before starting the training, we will have to adjust our loss that we have used for language model to account for different input that we discussed in the previous section. In the language model, we had one-hot encoded tensor (character) as an input on each timestep and one-hot encoded tensor as output (predicted next character). As we had to make a single exlusive choice for predicted next character, we used cross-entropy loss.
But now our model outputs a vector which is no longer one-hot encoded (multiple keys can be pressed). Of course, we can treat all possible combinations of pressed keys as a separate class, but this is intractable. Instead, we will treat each element of the output vector as a binary variable ( – pressing, – not pressing a key). We will define a separate loss for each element of the output vector to be binary cross-entropy. And our final loss will be an averaged sum of these binary cross-entropies. You can also read the code to get a better understanding.
After making the aforementioned changes, we trained our model. In the next section, we will perform sampling and inspect the results.
Sampling from pitch-level RNN
We have sampled piano rolls during the early stages of optimization:
You can see that our model is starting to learn one common pattern that is common among the songs from our dataset: each song consists of two different parts. First part contains a sequence of pitches that are played separately and are very distinguishable and are often singable (also know as melody). If you look at the sampled piano roll, this part can be clearly seen in the bottom. If you also have a look at the top of our piano roll, we can see a group of pitches that are usually played together – this is harmony or a progression of chords (pitches that are played together throughout the song) which accompanies the melody.
By the end of the training samples drawn from our model started to look like this:
As you can see they started to look more similar to the picture of the ground-truth piano roll that we showed in the previous sections.
After training, we have sampled songs and analyzed them. We got one sample with an interesting introduction. While another sample features a nice style transition. At the same time we generated a couple of examples with low temperature parameter which resulted in songs with a slow tempo: first one and a second one here. You can find the whole playlist here.
Now let’s look at our problem from the gpu memory consumption and speed point of view.
We greatly speed up computation by processing our sequences in batches. At the same time, as our sequences become longer (depending on the dataset), our max batch size starts to decrease. Why is it a case? As we use backpropagation to compute gradients, we need to store all the intermediate acitvations, which contribute the most to the memory consumption. As our sequence becomes longer, we need to store more activations, therefore, we can fit less examples in our batch.
Sometimes, we either have to work with really long sequences or we want to increase our batch size or maybe you just have a gpu with small amount of memory available. There are multiple possible solutions to reduce memory consumption in this case, but we will mention two, which will have different trade-offs.
First one is a truncated back propagation. The idea is to split the whole sequence into subsequences and treat them as separate batches with an exception that we process these batches in the order of split and every next batch uses hidden state of previous batch as an initial hidden state. We also provide an implementation of this approach, so that you can get the better understanding. This approach is obviously not an exact equivalent of processing the whole sequence but it makes more frequent updates and consumes less memory. On the other hand, there is a chance that we might not be able to capture long-term dependencies that span beyond the length of one subsequence.
Second one is gradient checkpointing. This method gives us a possibilty to use less memory while training our model on the whole sequence on the expence of performing more computation. If you recall, previously we mentioned that the most memory during training is occupied by activations. The idea of gradient checkpointing consists of storing only every -th activation and recomputing the unsaved activations later. This method is already implemented in Tensorflow and being implemented in Pytorch.
Conclusion and future work
In our work we trained simple generative model for text, extended our model to work with polyphonic music, briefly looked at how sampling works and how the temperature parameter affects our text and music samples – low temperature gives more stable results while high temperature adds more randomness which sometimes gives rise to very interesting samples.
Future work can include two directions – more applications or deeper analysis of the already trained models. Same models can be applied to your spotify listening history, for example. After training on your listening history data, you can give it a sequence of songs that you have listened to in the previous hour or so, and it will sample a playlist for you for the rest of the day. Well, you can also do the same for your browsing history, which will be just a cool tool to analyze your browsing behaviour patterns. Capture the accelerometer and gyroscope data from your phone while doing different activities (exercising in the gym, working in the office, sleeping) and learn to classify these activity stages. After that you can change your music playlist automatically, based on your activity (sleeping – calm music of rain, exercising in the gym – high intensity music). In terms of medical applications, model can be applied to detect heart problems based on pulse and other data, similar to this work.
It would be very interesting to analyze the neuron firings in our RNN trained for music generation like here. To see if the model learned some simple music concepts implicitly (like our discussion of harmony and melody). The hidden representation of RNN can be used to cluster our music dataset to find similar songs.
Let’s sample one last lyrics from our unconditional model to conclude this post 😀 :
The story ends
The sound of the blue
The tears were shining
The story of my life
I still believe
The story of my life
