JS Drum Kit

diff --git a/01 - JavaScript Drum Kit/index.js b/01 - JavaScript Drum Kit/index.js new file mode 100644 index 0000000000..bb775a0237 --- /dev/null +++ b/01 - JavaScript Drum Kit/index.js @@ -0,0 +1,25 @@ +const ks = [...document.querySelectorAll('.key')]; + +// add event to k +ks.forEach((k) => { + k.addEventListener('transitionend', (e) => { + if (e.propertyName !== 'transform') return; + e.target.classList.remove('playing'); + console.log(e); + }); +}); + +window.addEventListener('keydown', (e) => playSound(e.keyCode)); + +function playSound(code) { + const btn = document.querySelector(`div[data-key='${code}']`); + const audio = document.querySelector(`audio[data-key='${code}']`); + if (!audio) return; + + btn.classList.add('playing'); + audio.currentTime = 0; + audio.play(); + + // setTimeout(() => btn.classList.remove('playing'), 500); + // console.log(code, btn, audio); +} diff --git a/01 - JavaScript Drum Kit/index0.html b/01 - JavaScript Drum Kit/index0.html new file mode 100644 index 0000000000..421f2353e9 --- /dev/null +++ b/01 - JavaScript Drum Kit/index0.html @@ -0,0 +1,60 @@ + + + + + JS Drum Kit + + + +

+ A + clap +

+ S + hihat +

+ D + kick +

+ F + openhat +

+ G + boom +

+ H + ride +

+ J + snare +

+ K + tom +

+ L + tink +

+ +

+ + + + diff --git a/02 - JS and CSS Clock/index.js b/02 - JS and CSS Clock/index.js new file mode 100644 index 0000000000..eef455e456 --- /dev/null +++ b/02 - JS and CSS Clock/index.js @@ -0,0 +1,23 @@ +const data = { + digitclock: document.querySelector('#digitclock'), + shand: document.querySelector('.second-hand'), + mhand: document.querySelector('.min-hand'), + hhand: document.querySelector('.hour-hand'), +}; + +function showtime({ digitclock, shand, mhand, hhand }) { + const t = new Date(), + sdeg = t.getSeconds() * (360 / 60) + 90, + mdeg = + t.getMinutes() * (360 / 60) + 90 + ((t.getSeconds() / 60) * 360) / 60, + hdeg = t.getHours() * (360 / 12) + 90 + t.getMinutes() * 0.5; + + digitclock.textContent = t.toLocaleTimeString(); + shand.style.transform = `rotate(${sdeg}deg)`; + mhand.style.transform = `rotate(${mdeg}deg)`; + hhand.style.transform = `rotate(${hdeg}deg)`; +} + +const iPnt = setInterval(() => showtime(data), 1000); + +// showtime(data); diff --git a/02 - JS and CSS Clock/index0.html b/02 - JS and CSS Clock/index0.html new file mode 100644 index 0000000000..17d9b52c4e --- /dev/null +++ b/02 - JS and CSS Clock/index0.html @@ -0,0 +1,83 @@ + + + + + JS + CSS Clock + + +

+ +

time

+ + + + + + diff --git a/03 - CSS Variables/index0.html b/03 - CSS Variables/index0.html new file mode 100644 index 0000000000..83eeddd553 --- /dev/null +++ b/03 - CSS Variables/index0.html @@ -0,0 +1,91 @@ + + + + + Scoped CSS Variables and JS + + +

Update CSS Variables with JS

+ +

+ Spacing: + + + Blur: + + + Base Color + +

+ + + + + + + + diff --git a/05 - Flex Panel Gallery/index0.html b/05 - Flex Panel Gallery/index0.html new file mode 100644 index 0000000000..89e5a7776c --- /dev/null +++ b/05 - Flex Panel Gallery/index0.html @@ -0,0 +1,133 @@ + + + + + Flex Panels 💪 + + + + +

Hey

Let's

Dance

Give

Take

Receive

Experience

Today

Give

All

You can

Life

Motion

+ + + + diff --git a/06 - Type Ahead/app/app.js b/06 - Type Ahead/app/app.js new file mode 100644 index 0000000000..8b2989fe85 --- /dev/null +++ b/06 - Type Ahead/app/app.js @@ -0,0 +1,185 @@ +import { Suggestions } from './components.js'; +// Utilities Start ==================== +const pr = console.log; +// Utilities End ==================== + +// App Start ==================== +// +export class EventRegistry { + constructor() { + this.map = new Map(); + } + + fire(event) { + for (const cb of this.map.get(event.name) || []) { + cb(event); + } + } + + listen(eventName, cb) { + const cbs = this.map.get(eventName) || []; + cbs.push(cb); + this.map.set(eventName, cbs); + } + unListen(eventName, cb) { + const cbs = this.map.get(eventName) || []; + this.map.set( + eventName, + cbs.filter((x) => x != cb), + ); + } +} + +export class Place { + constructor(city, st) { + this.city = city; + this.st = st; + } +} + +export const App = new EventRegistry(); +App.filter = ''; + +App.setupDispatch = () => { + pr('App.setupDispatch App:', App); + App.db.onmessage = (e) => { + const { op, error } = e.data; + pr(op, 'data:', e.data); + switch (op) { + case 'addDone': + if (!error) { + App.getPlaces(App.filter); + App.fire({ name: 'addCity success', data: e.data }); + } else { + App.fire({ name: 'addCity error', error: e.data.error.message }); + } + break; + case 'delDone': + if (!error) { + App.getPlaces(App.filter); + } else { + App.fire({ name: 'delCity error', error: e.data.error.message }); + } + break; + case 'getDone': + App.fire({ name: 'placesChange', data: e.data }); + break; + default: + pr('App.onmessage.default'); + } + }; +}; + +App.getPlaces = (pattern) => { + const msg = { op: 'get', path: 'place', pattern: pattern }; + pr('App.getPlaces msg:', msg); + App.db.postMessage(msg); +}; + +App.filterChange = (pattern) => { + App.filter = pattern; + App.getPlaces(pattern); + pr('App.filterChange pattern:', pattern); + App.fire({ name: 'filterChange', filter: pattern }); +}; + +App.addCity = (str) => { + const [city, st] = str + .toLowerCase() + .split(',') + .map((x) => x.trim()); + if (city && st) { + App.db.postMessage({ op: 'add', path: 'place', obj: new Place(city, st) }); + } +}; + +App.delCity = (city, st) => { + App.db.postMessage({ op: 'del', path: 'place', obj: new Place(city, st) }); +}; + +App.init = () => { + App.db = new Worker('store-worker.js'); + App.setupDispatch(); + + const suggestionsDiv = document.querySelector('.suggestions'); + App.listen('placesChange', ({ data }) => { + const places = data.data; + pr('suggestionsDiv, placesChange, data:', data, places); + const component = Suggestions({ + places: places, + onDel: (city, st) => App.delCity(city, st), + onEdit: (city, st) => App.editCity(city, st), + }); + render(suggestionsDiv, component); + }); + + // filters + // TODO: throttle keyup events for 200ms // + document.querySelectorAll('.filter').forEach((el) => { + el.addEventListener('keyup', (e) => App.filterChange(e.target.value)); + App.listen('filterChange', ({ filter }) => { + if (el.value !== filter) el.value = filter; + }); + }); + + // add city + const addInp = document.querySelector('.add'); + addInp.addEventListener('change', (e) => App.addCity(e.target.value)); + App.listen('addCity success', () => { + addInp.value = ''; + }); + App.listen('addCity error', (e) => { + addInp.value = e.error; + }); + + // const { place, err } = App.addCity(e.target.value); + // if (err) { + // pr('Error', err); + // return; + // } + // const event = { name: 'PlacesChange', place: place }; + // App.eReg.fireEvent(event); + // e.target.value = ''; + // }); +}; + +// Element, Element -> DOM Effect +function render(root, component) { + root.replaceChildren(component); +} + +// App End ==================== + +// App Run ==================== +App.init(); + +// e// // str, str -> err: str +// delCity(city, st) { +// pr(city, st); +// this._places.delete(this.key(city, st)); +// this.eReg.fireEvent({ +// name: 'placesChange', +// city: city, +// st: st, +// details: 'delete', +// }); +// } + +// // str, str -> err: str +// editCity(city, st) { +// pr(city, st); +// } +// } + +// export const app = new App(new Worker('store-worker.js')); +// App End ==================== + +// store-worker Start ==================== +// const store = new Worker('store-worker.js'); + +// window.onload = (e) => { +// pr('onload', e); +// store.postMessage({ op: 'get', path: 'place', pattern: '' }); +// }; + +// store-worker End ==================== diff --git a/06 - Type Ahead/app/components.js b/06 - Type Ahead/app/components.js new file mode 100644 index 0000000000..784bc414e3 --- /dev/null +++ b/06 - Type Ahead/app/components.js @@ -0,0 +1,76 @@ +// Utilitis +const pr = console.table; +const Element = (tag) => document.createElement(tag); + +// {places, ...[onChangeFn]} -> Element('ul') +export function Suggestions({ places, onDel, onEdit }) { + pr('Suggestions places:', places); + const lst = places.map(({ city, st }) => { + const li = Element('li'), + c = Element('span'), + s = Element('span'), + del = Element('button'), + ed = Element('button'), + sbtn = Element('span'); + c.append(city); + s.append(st); + del.append('Del'); + del.addEventListener('click', () => { + onDel(city, st); + }); + ed.append('Edit'); + ed.addEventListener('click', () => { + onEdit(city, st); + }); + sbtn.append(ed, del); + li.append(c, s, sbtn); + return li; + }); + const ul = Element('ul'); + ul.append(...lst); + return ul; +} +// ========== + +// const suggestions = document.querySelector('.suggestions'); +// // str, Element -> +// function showSuggestions(pattern, rootEl) { +// const ps = App.places(pattern), +// lis = placesList({ +// places: ps, +// onDel: (city, st) => App.delCity(city, st), +// onEdit: (city, st) => App.editCity(city, st), +// }); +// rootEl.replaceChildren(...lis); +// } + +// App.eReg.listen('SearchChange', ({ pattern }) => +// showSuggestions(pattern, suggestions), +// ); + +// App.eReg.listen('PlacesChange', () => { +// const pattern = search.value; +// showSuggestions(pattern, suggestions); +// }); + +// showSuggestions('', suggestions); +// ========== + +// const search = document.querySelector('.search'); +// search.addEventListener('keyup', (e) => { +// const event = { name: 'SearchChange', pattern: e.target.value }; +// App.eReg.fireEvent(event); +// }); +// // ========== + +// const add = document.querySelector('.add'); +// add.addEventListener('change', (e) => { +// const { place, err } = App.addCity(e.target.value); +// if (err) { +// pr('Error', err); +// return; +// } +// const event = { name: 'PlacesChange', place: place }; +// App.eReg.fireEvent(event); +// e.target.value = ''; +// }); diff --git a/06 - Type Ahead/app/index.js b/06 - Type Ahead/app/index.js new file mode 100644 index 0000000000..24187679de --- /dev/null +++ b/06 - Type Ahead/app/index.js @@ -0,0 +1,164 @@ +// Utilitis +const pr = console.table; +const Element = (tag) => document.createElement(tag); + +class EventRegistry { + constructor() { + this.map = new Map(); + } + + fireEvent(event) { + for (const cb of this.map.get(event.name) || []) { + cb(event); + } + } + + listen(eventName, cb) { + const cbs = this.map.get(eventName) || []; + cbs.push(cb); + this.map.set(eventName, cbs); + } + unListen(eventName, cb) { + const cbs = this.map.get(eventName) || []; + this.map.set( + eventName, + cbs.filter((x) => x != cb), + ); + } +} + +const App = { + eReg: new EventRegistry(), + _places: new Map(), + + init() { + // init places + const _cs = ['Madera,ca', 'Fresno, CA', 'boulder, co', 'austin,tx']; + for (const s of _cs) { + this.addCity(s); + } + }, + + // str -> [place] + places(pattern) { + const r = new RegExp(pattern, 'gi'), + res = []; + this._places.forEach((v, k) => { + if (k.match(r)) res.push(v); + }); + return res; + }, + + // str, str -> str + key(city, st) { + return `${city},${st}`; + }, + + // str -> {place: obj, err: str} + addCity(str) { + const [city, st] = str + .toLowerCase() + .split(',') + .map((x) => x.trim()); + const key = this.key(city, st), + place = { city: city, st: st }; + if (this._places.has(key)) return { place: null, err: 'key exists' }; + this._places.set(key, place); + this.eReg.fireEvent({ name: 'PlacesChange', city: city, st: st }); + return { place: place, err: '' }; + }, + + // str, str -> err: str + delCity(city, st) { + pr(city, st); + this._places.delete(this.key(city, st)); + this.eReg.fireEvent({ + name: 'PlacesChange', + city: city, + st: st, + details: 'delete', + }); + }, + + // str, str -> err: str + editCity(city, st) { + pr(city, st); + }, +}; + +App.init(); +// ========== + +// Componets +// +// [places], rootElment -> [Element('li')] +function placesList({ places, onDel, onEdit }) { + const lst = places.map(({ city, st }) => { + const li = Element('li'), + c = Element('span'), + s = Element('span'), + del = Element('button'), + ed = Element('button'), + sbtn = Element('span'); + c.append(city); + s.append(st); + del.append('Del'); + del.addEventListener('click', () => { + onDel(city, st); + }); + ed.append('Edit'); + ed.addEventListener('click', () => { + onEdit(city, st); + }); + sbtn.append(ed, del); + li.append(c, s, sbtn); + return li; + }); + return lst; +} +// ========== + +const suggestions = document.querySelector('.suggestions'); +// str, Element -> +function showSuggestions(pattern, rootEl) { + const ps = App.places(pattern), + lis = placesList({ + places: ps, + onDel: (city, st) => App.delCity(city, st), + onEdit: (city, st) => App.editCity(city, st), + }); + rootEl.replaceChildren(...lis); +} + +App.eReg.listen('SearchChange', ({ pattern }) => + showSuggestions(pattern, suggestions), +); + +App.eReg.listen('PlacesChange', () => { + const pattern = search.value; + showSuggestions(pattern, suggestions); +}); + +showSuggestions('', suggestions); +// ========== + +const search = document.querySelector('.search'); +search.addEventListener('keyup', (e) => { + const event = { name: 'SearchChange', pattern: e.target.value }; + App.eReg.fireEvent(event); +}); +// ========== + +const add = document.querySelector('.add'); +add.addEventListener('change', (e) => { + const { place, err } = App.addCity(e.target.value); + if (err) { + pr('Error', err); + return; + } + const event = { name: 'PlacesChange', place: place }; + App.eReg.fireEvent(event); + e.target.value = ''; +}); + +// END Componets =============== diff --git a/06 - Type Ahead/app/main.html b/06 - Type Ahead/app/main.html new file mode 100644 index 0000000000..43ea172970 --- /dev/null +++ b/06 - Type Ahead/app/main.html @@ -0,0 +1,36 @@ + + + + + Type Ahead 👀 + + + +

+ 2nd filter + +

+ +

Filter for a city
or a state

+ + + diff --git a/06 - Type Ahead/app/mocha b/06 - Type Ahead/app/mocha new file mode 120000 index 0000000000..67d7fb6daa --- /dev/null +++ b/06 - Type Ahead/app/mocha @@ -0,0 +1 @@ +/Users/v/code/learning/js/mocha \ No newline at end of file diff --git a/06 - Type Ahead/app/store-worker.js b/06 - Type Ahead/app/store-worker.js new file mode 100644 index 0000000000..5a930ce1e2 --- /dev/null +++ b/06 - Type Ahead/app/store-worker.js @@ -0,0 +1,130 @@ +// import { Place } from './app.js'; +const pr = console.log; +let db; + +const connection = indexedDB.open('cities', 1); + +connection.onerror = (e) => pr('why not allow to use indexedDB?'); + +connection.onupgradeneeded = (e) => { + pr('in connection.onupgradeneeded'); + db = e.target.result; + db.onerror = (e) => console.error('Error loading db'); + + // create objectStore + const objectStore = db.createObjectStore('place', { keyPath: 'key' }); + // define data items + // objectStore.createIndex('zip', 'zip', {unique: false}) + + //populate with initial data + objectStore.transaction.oncomplete = (e) => { + pr('onupgradeneeded oncomplete, e', e); + add(db, { + op: 'add', + path: 'place', + obj: { city: 'example city', st: 'ny' }, + }); + }; +}; + +connection.onsuccess = (e) => { + pr('in connection.onsuccess'); + db = e.target.result; + // setupDispatch(db); + // get all places + get(db, { + op: 'get', + path: 'place', + pattern: '', + }); +}; + +// setupDispatch +onmessage = (event) => { + const { op } = event.data; + switch (op) { + case 'get': + get(db, event.data); + break; + + case 'add': + add(db, event.data); + break; + + case 'del': + del(db, event.data); + break; + default: + pr('worker.setupDispatch.default', event.data); + } +}; + +function key({ city, st }) { + return `${city},${st}`; +} + +function add(db, data) { + const { path, obj } = data; + if (path === 'place') { + obj.key = key(obj); + } + + const transaction = db.transaction([path], 'readwrite'); + const objectStore = transaction.objectStore(path); + const req = objectStore.add(obj); + + req.onsuccess = (e) => { + const res = { data: e.target.result, op: 'addDone', error: '' }; + postMessage(res); + }; + req.onerror = (e) => { + const res = { data: e.target.result, op: 'addDone', error: e.target.error }; + postMessage(res); + }; +} + +function get(db, data) { + const { path, pattern } = data; + const r = new RegExp(pattern, 'gi'), + trans = db.transaction([path]), + items = []; + + objectStore = trans.objectStore(path); + + objectStore.openCursor().onsuccess = (e) => { + const cursor = e.target.result; + if (!cursor) { + pr('lookup is done'); + const res = { op: 'getDone', data: items, pattern: pattern, error: '' }; + postMessage(res); + return; + } + const item = cursor.value; + if (item.key.match(r)) items.push(item); + cursor.continue(); + }; +} + +function del(db, data) { + const { path, obj } = data; + if (path === 'place') { + obj.key = key(obj); + } + + const transaction = db.transaction([path], 'readwrite'); + const objectStore = transaction.objectStore(path); + const req = objectStore.delete(obj.key); + + req.onsuccess = (e) => { + const res = { data: e.target.result, op: 'delDone', error: '' }; + postMessage(res); + }; + req.onerror = (e) => { + const res = { + data: e.target.result, + op: 'delDone', + error: e.target.error, + }; + postMessage(res); + }; +} diff --git a/06 - Type Ahead/app/style.css b/06 - Type Ahead/app/style.css new file mode 100644 index 0000000000..2e62f4e331 --- /dev/null +++ b/06 - Type Ahead/app/style.css @@ -0,0 +1,84 @@ +html { + box-sizing: border-box; + background: #ffc600; + font-family: 'helvetica neue'; + font-size: 20px; + font-weight: 200; +} + +*, +*:before, +*:after { + box-sizing: inherit; +} + +div.utils { + border: 2px dotted black; +} +.utils input { + width: 30%; + height: 20px; +} + +input { + width: 100%; + padding: 20px; +} + +.search-form { + max-width: 400px; + margin: 50px auto; +} + +input.search { + margin: 0; + text-align: center; + outline: 0; + border: 10px solid #f7f7f7; + width: 120%; + left: -10%; + position: relative; + top: 10px; + z-index: 2; + border-radius: 5px; + font-size: 40px; + box-shadow: 0 0 5px rgba(0, 0, 0, 0.12), inset 0 0 2px rgba(0, 0, 0, 0.19); +} + +.suggestions { + margin: 0; + padding: 0; + position: relative; + /*perspective: 20px;*/ +} + +.suggestions li { + background: white; + list-style: none; + border-bottom: 1px solid #d8d8d8; + box-shadow: 0 0 10px rgba(0, 0, 0, 0.14); + margin: 0; + padding: 20px; + transition: background 0.2s; + display: flex; + justify-content: space-between; + text-transform: capitalize; +} + +.suggestions li:nth-child(even) { + transform: perspective(100px) rotateX(3deg) translateY(2px) scale(1.001); + background: linear-gradient(to bottom, #ffffff 0%, #efefef 100%); +} + +.suggestions li:nth-child(odd) { + transform: perspective(100px) rotateX(-3deg) translateY(3px); + background: linear-gradient(to top, #ffffff 0%, #efefef 100%); +} + +span.population { + font-size: 15px; +} + +.hl { + background: #ffc600; +} diff --git a/06 - Type Ahead/app/t.spec.js b/06 - Type Ahead/app/t.spec.js new file mode 100644 index 0000000000..6ea37cea6f --- /dev/null +++ b/06 - Type Ahead/app/t.spec.js @@ -0,0 +1,82 @@ +const assert = chai.assert; +import { Place, App, EventRegistry } from './app.js'; + +const pr = console.log; + +describe('function', () => { + it('desctructure arguments', () => { + function add({ a, b }) { + return a + b; + } + const props = { a: 1, b: 3 }; + assert.equal(4, add(props)); + }); +}); + +describe('class', () => { + it('desctructure class obj', () => { + const place = new Place('a', 'ca'); + const { city, st } = place; + assert.equal('a', city); + }); + it('extends', () => { + class A { + constructor(x) { + this.x = x; + } + add(y) { + return this.x + y; + } + sub(y) { + return this.x - y; + } + } + class B extends A { + constructor(x) { + super(x); + } + add(y) { + return this.x * y; + } + } + const a = new A(1), + b = new B(1); + + assert.equal(a.add(1), 2); + assert.equal(a.sub(1), 0); + assert.equal(b.sub(1), 0); + assert.equal(b.add(1), 1); + }); +}); + +describe('App', () => { + it('extends EventRegistry', () => { + class Reg extends EventRegistry { + constructor(x) { + super(); + this.x = x; + this.listen('change a', (e) => { + // pr('in Reg.constructor, e', e); + }); + } + f(x) { + this.fire({ name: 'change a', data: x }); + } + } + + const reg = new Reg(1), + a = { a: 1, b: 2 }, + b = { a: 1, b: 2 }; + + reg.listen('change a', (e) => { + // pr('in describe App, e', e); + b.a = e.data + b.a; + }); + assert.deepEqual({ a: 1, b: 2 }, b); + reg.fire({ name: 'change a', data: 1 }); + assert.deepEqual({ a: 2, b: 2 }, b); + + reg.f(2); + assert.deepEqual({ a: 4, b: 2 }, b); + }); +}); diff --git a/06 - Type Ahead/app/tests.html b/06 - Type Ahead/app/tests.html new file mode 100644 index 0000000000..0766a8b57c --- /dev/null +++ b/06 - Type Ahead/app/tests.html @@ -0,0 +1,30 @@ + + + + + Mocha Tests + + + + + +

+ + + + + + + + + + + + + + diff --git a/06 - Type Ahead/cities.json b/06 - Type Ahead/cities.json new file mode 100644 index 0000000000..259103a7b8 --- /dev/null +++ b/06 - Type Ahead/cities.json @@ -0,0 +1 @@ +[{ "1": 2 }, { "1": 2 }] diff --git a/06 - Type Ahead/events.html b/06 - Type Ahead/events.html new file mode 100644 index 0000000000..ca531685c7 --- /dev/null +++ b/06 - Type Ahead/events.html @@ -0,0 +1,21 @@ + + + + + Type Ahead 👀 + + + +

+ +

Filter for a city
or a state

+ + + diff --git a/06 - Type Ahead/events.js b/06 - Type Ahead/events.js new file mode 100644 index 0000000000..24187679de --- /dev/null +++ b/06 - Type Ahead/events.js @@ -0,0 +1,164 @@ +// Utilitis +const pr = console.table; +const Element = (tag) => document.createElement(tag); + +class EventRegistry { + constructor() { + this.map = new Map(); + } + + fireEvent(event) { + for (const cb of this.map.get(event.name) || []) { + cb(event); + } + } + + listen(eventName, cb) { + const cbs = this.map.get(eventName) || []; + cbs.push(cb); + this.map.set(eventName, cbs); + } + unListen(eventName, cb) { + const cbs = this.map.get(eventName) || []; + this.map.set( + eventName, + cbs.filter((x) => x != cb), + ); + } +} + +const App = { + eReg: new EventRegistry(), + _places: new Map(), + + init() { + // init places + const _cs = ['Madera,ca', 'Fresno, CA', 'boulder, co', 'austin,tx']; + for (const s of _cs) { + this.addCity(s); + } + }, + + // str -> [place] + places(pattern) { + const r = new RegExp(pattern, 'gi'), + res = []; + this._places.forEach((v, k) => { + if (k.match(r)) res.push(v); + }); + return res; + }, + + // str, str -> str + key(city, st) { + return `${city},${st}`; + }, + + // str -> {place: obj, err: str} + addCity(str) { + const [city, st] = str + .toLowerCase() + .split(',') + .map((x) => x.trim()); + const key = this.key(city, st), + place = { city: city, st: st }; + if (this._places.has(key)) return { place: null, err: 'key exists' }; + this._places.set(key, place); + this.eReg.fireEvent({ name: 'PlacesChange', city: city, st: st }); + return { place: place, err: '' }; + }, + + // str, str -> err: str + delCity(city, st) { + pr(city, st); + this._places.delete(this.key(city, st)); + this.eReg.fireEvent({ + name: 'PlacesChange', + city: city, + st: st, + details: 'delete', + }); + }, + + // str, str -> err: str + editCity(city, st) { + pr(city, st); + }, +}; + +App.init(); +// ========== + +// Componets +// +// [places], rootElment -> [Element('li')] +function placesList({ places, onDel, onEdit }) { + const lst = places.map(({ city, st }) => { + const li = Element('li'), + c = Element('span'), + s = Element('span'), + del = Element('button'), + ed = Element('button'), + sbtn = Element('span'); + c.append(city); + s.append(st); + del.append('Del'); + del.addEventListener('click', () => { + onDel(city, st); + }); + ed.append('Edit'); + ed.addEventListener('click', () => { + onEdit(city, st); + }); + sbtn.append(ed, del); + li.append(c, s, sbtn); + return li; + }); + return lst; +} +// ========== + +const suggestions = document.querySelector('.suggestions'); +// str, Element -> +function showSuggestions(pattern, rootEl) { + const ps = App.places(pattern), + lis = placesList({ + places: ps, + onDel: (city, st) => App.delCity(city, st), + onEdit: (city, st) => App.editCity(city, st), + }); + rootEl.replaceChildren(...lis); +} + +App.eReg.listen('SearchChange', ({ pattern }) => + showSuggestions(pattern, suggestions), +); + +App.eReg.listen('PlacesChange', () => { + const pattern = search.value; + showSuggestions(pattern, suggestions); +}); + +showSuggestions('', suggestions); +// ========== + +const search = document.querySelector('.search'); +search.addEventListener('keyup', (e) => { + const event = { name: 'SearchChange', pattern: e.target.value }; + App.eReg.fireEvent(event); +}); +// ========== + +const add = document.querySelector('.add'); +add.addEventListener('change', (e) => { + const { place, err } = App.addCity(e.target.value); + if (err) { + pr('Error', err); + return; + } + const event = { name: 'PlacesChange', place: place }; + App.eReg.fireEvent(event); + e.target.value = ''; +}); + +// END Componets =============== diff --git a/06 - Type Ahead/worker/app.js b/06 - Type Ahead/worker/app.js new file mode 100644 index 0000000000..54b2904e56 --- /dev/null +++ b/06 - Type Ahead/worker/app.js @@ -0,0 +1,6 @@ +import { Lst } from './lst.js'; + +const pr = console.log; + +pr('hi'); +pr(Lst.map((x) => x.name + x.val)); diff --git a/06 - Type Ahead/worker/index.html b/06 - Type Ahead/worker/index.html new file mode 100644 index 0000000000..20e0408efc --- /dev/null +++ b/06 - Type Ahead/worker/index.html @@ -0,0 +1,21 @@ + + + + + Type Ahead 👀 + + + +

+ +

Filter for a city
or a state

+ + + diff --git a/06 - Type Ahead/worker/lst.js b/06 - Type Ahead/worker/lst.js new file mode 100644 index 0000000000..0917c41274 --- /dev/null +++ b/06 - Type Ahead/worker/lst.js @@ -0,0 +1,5 @@ +export const Lst = [ + { name: 'a', val: 'aa' }, + { name: 'b', val: 'bb' }, + { name: 'c', val: 'cc' }, +]; diff --git a/27 - Click and Drag/index-FINISHED.html b/27 - Click and Drag/index-FINISHED.html index 52eb86628c..aefeedcddc 100644 --- a/27 - Click and Drag/index-FINISHED.html +++ b/27 - Click and Drag/index-FINISHED.html @@ -1,71 +1,69 @@ - - - Click and Drag - - - -

+ + + Click and Drag + + + +

- + slider.addEventListener('mouseup', () => { + isDown = false; + slider.classList.remove('active'); + }); + slider.addEventListener('mousemove', (e) => { + if (!isDown) return; // stop the fn from running + e.preventDefault(); + const x = e.pageX - slider.offsetLeft; + const walk = (x - startX) * 3; + slider.scrollLeft = scrollLeft - walk; + }); + diff --git a/data/cities.json b/data/cities.json new file mode 100644 index 0000000000..259103a7b8 --- /dev/null +++ b/data/cities.json @@ -0,0 +1 @@ +[{ "1": 2 }, { "1": 2 }] diff --git a/lab1/PT_Part2_Music_Generation.ipynb b/lab1/PT_Part2_Music_Generation.ipynb new file mode 100644 index 0000000000..7c9722391d --- /dev/null +++ b/lab1/PT_Part2_Music_Generation.ipynb @@ -0,0 +1,1438 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + " $\"Open$ " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uoJsVjtCMunI" + }, + "source": [ + "\n", + " \n", + " \n", + " \n", + "

\n", + "

\n", + " Visit MIT Deep Learning

\n", + "

Run in Google Colab

\n", + "

View Source on GitHub

\n", + "\n", + "# Copyright Information" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bUik05YqMyCH" + }, + "outputs": [], + "source": [ + "# Copyright 2025 MIT Introduction to Deep Learning. All Rights Reserved.\n", + "#\n", + "# Licensed under the MIT License. You may not use this file except in compliance\n", + "# with the License. Use and/or modification of this code outside of MIT Introduction\n", + "# to Deep Learning must reference:\n", + "#\n", + "# © MIT Introduction to Deep Learning\n", + "# http://introtodeeplearning.com\n", + "#" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O-97SDET3JG-" + }, + "source": [ + "# Lab 1: Intro to PyTorch and Music Generation with RNNs\n", + "\n", + "# Part 2: Music Generation with RNNs\n", + "\n", + "In this portion of the lab, we will explore building a Recurrent Neural Network (RNN) for music generation using PyTorch. We will train a model to learn the patterns in raw sheet music in [ABC notation](https://en.wikipedia.org/wiki/ABC_notation) and then use this model to generate new music." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rsvlBQYCrE4I" + }, + "source": [ + "## 2.1 Dependencies\n", + "First, let's download the course repository, install dependencies, and import the relevant packages we'll need for this lab.\n", + "\n", + "We will be using [Comet ML](https://www.comet.com/docs/v2/) to track our model development and training runs. First, sign up for a Comet account [at this link](https://www.comet.com/signup?utm_source=mit_dl&utm_medium=partner&utm_content=github\n", + ") (you can use your Google or Github account). You will need to generate a new personal API Key, which you can find either in the first 'Get Started with Comet' page, under your account settings, or by pressing the '?' in the top right corner and then 'Quickstart Guide'. Enter this API key as the global variable `COMET_API_KEY`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "riVZCVK65QTH" + }, + "outputs": [], + "source": [ + "!pip install comet_ml > /dev/null 2>&1\n", + "import comet_ml\n", + "# TODO: ENTER YOUR API KEY HERE!! instructions above\n", + "COMET_API_KEY = \"rom6izyKhaALsVmPeV0NjkAmQ\"\n", + "\n", + "# Import PyTorch and other relevant libraries\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "# Download and import the MIT Introduction to Deep Learning package\n", + "!pip install mitdeeplearning --quiet\n", + "import mitdeeplearning as mdl\n", + "\n", + "# Import all remaining packages\n", + "import numpy as np\n", + "import os\n", + "import time\n", + "import functools\n", + "from IPython import display as ipythondisplay\n", + "from tqdm import tqdm\n", + "from scipy.io.wavfile import write\n", + "!apt-get install abcmidi timidity > /dev/null 2>&1\n", + "\n", + "\n", + "# Check that we are using a GPU, if not switch runtimes\n", + "# using Runtime > Change Runtime Type > GPU\n", + "assert torch.cuda.is_available(), \"Please enable GPU from runtime settings\"\n", + "assert COMET_API_KEY != \"\", \"Please insert your Comet API Key\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_ajvp0No4qDm" + }, + "source": [ + "## 2.2 Dataset\n", + "\n", + "![Let's Dance!](http://33.media.tumblr.com/3d223954ad0a77f4e98a7b87136aa395/tumblr_nlct5lFVbF1qhu7oio1_500.gif)\n", + "\n", + "We've gathered a dataset of thousands of Irish folk songs, represented in the ABC notation. Let's download the dataset and inspect it:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "P7dFnP5q3Jve", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ab4ed7d0-b691-4988-ac61-b64d7493e69f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 817 songs in text\n", + "\n", + "Example song: \n", + "X:1\n", + "T:Alexander's\n", + "Z: id:dc-hornpipe-1\n", + "M:C|\n", + "L:1/8\n", + "K:D Major\n", + "(3ABc|dAFA DFAd|fdcd FAdf|gfge fefd|(3efe (3dcB A2 (3ABc|!\n", + "dAFA DFAd|fdcd FAdf|gfge fefd|(3efe dc d2:|!\n", + "AG|FAdA FAdA|GBdB GBdB|Acec Acec|dfaf gecA|!\n", + "FAdA FAdA|GBdB GBdB|Aceg fefd|(3efe dc d2:|!\n" + ] + } + ], + "source": [ + "# Download the dataset\n", + "songs = mdl.lab1.load_training_data()\n", + "\n", + "# Print one of the songs to inspect it in greater detail!\n", + "example_song = songs[0]\n", + "print(\"\\nExample song: \")\n", + "print(example_song)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hKF3EHJlCAj2" + }, + "source": [ + "We can easily convert a song in ABC notation to an audio waveform and play it back. Be patient for this conversion to run, it can take some time." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "11toYzhEEKDz", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 76 + }, + "outputId": "4e357c3a-5930-4202-bf85-5b8d8138a9ee" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "

\n", + " " + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "# Convert the ABC notation to audio file and listen to it\n", + "mdl.lab1.play_song(example_song)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7vH24yyquwKQ" + }, + "source": [ + "One important thing to think about is that this notation of music does not simply contain information on the notes being played, but additionally there is meta information such as the song title, key, and tempo. How does the number of different characters that are present in the text file impact the complexity of the learning problem? This will become important soon, when we generate a numerical representation for the text data." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "IlCgQBRVymwR", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1da28f96-951d-4b8a-aba4-7ab79fd682f0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "There are 83 unique characters in the dataset\n", + "['\\n', ' ', '!', '\"', '#', \"'\", '(', ')', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', '<', '=', '>', 'A', 'B', 'C', 'D']\n", + "len(songs)=817\n", + "len(songs[0])=252\n", + "len(songs[5])=234\n" + ] + } + ], + "source": [ + "# Join our list of song strings into a single string containing all songs\n", + "songs_joined = \"\\n\\n\".join(songs)\n", + "\n", + "# Find all unique characters in the joined string\n", + "vocab = sorted(set(songs_joined))\n", + "print(\"There are\", len(vocab), \"unique characters in the dataset\")\n", + "print(vocab[:30])\n", + "print(f'{len(songs)=}')\n", + "print(f'{len(songs[0])=}')\n", + "print(f'{len(songs[5])=}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rNnrKn_lL-IJ" + }, + "source": [ + "## 2.3 Process the dataset for the learning task\n", + "\n", + "Let's take a step back and consider our prediction task. We're trying to train an RNN model to learn patterns in ABC music, and then use this model to generate (i.e., predict) a new piece of music based on this learned information.\n", + "\n", + "Breaking this down, what we're really asking the model is: given a character, or a sequence of characters, what is the most probable next character? We'll train the model to perform this task.\n", + "\n", + "To achieve this, we will input a sequence of characters to the model, and train the model to predict the output, that is, the following character at each time step. RNNs maintain an internal state that depends on previously seen elements, so information about all characters seen up until a given moment will be taken into account in generating the prediction." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LFjSVAlWzf-N" + }, + "source": [ + "### Vectorize the text\n", + "\n", + "Before we begin training our RNN model, we'll need to create a numerical representation of our text-based dataset. To do this, we'll generate two lookup tables: one that maps characters to numbers, and a second that maps numbers back to characters. Recall that we just identified the unique characters present in the text.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "IalZLbvOzf-F" + }, + "outputs": [], + "source": [ + "### Define numerical representation of text ###\n", + "\n", + "# Create a mapping from character to unique index.\n", + "# For example, to get the index of the character \"d\",\n", + "# we can evaluate `char2idx[\"d\"]`.\n", + "char2idx = {u: i for i, u in enumerate(vocab)}\n", + "\n", + "# Create a mapping from indices to characters. This is\n", + "# the inverse of char2idx and allows us to convert back\n", + "# from unique index to the character in our vocabulary.\n", + "idx2char = np.array(vocab)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tZfqhkYCymwX" + }, + "source": [ + "This gives us an integer representation for each character. Observe that the unique characters (i.e., our vocabulary) in the text are mapped as indices from 0 to `len(unique)`. Let's take a peek at this numerical representation of our dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "FYyNlCNXymwY", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b4f230e1-5bb0-4942-be9f-05a20f335428" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{\n", + " '\\n': 0,\n", + " ' ' : 1,\n", + " '!' : 2,\n", + " '\"' : 3,\n", + " '#' : 4,\n", + " \"'\" : 5,\n", + " '(' : 6,\n", + " ')' : 7,\n", + " ',' : 8,\n", + " '-' : 9,\n", + " '.' : 10,\n", + " '/' : 11,\n", + " '0' : 12,\n", + " '1' : 13,\n", + " '2' : 14,\n", + " '3' : 15,\n", + " '4' : 16,\n", + " '5' : 17,\n", + " '6' : 18,\n", + " '7' : 19,\n", + " ...\n", + "}\n" + ] + } + ], + "source": [ + "print('{')\n", + "for char, _ in zip(char2idx, range(20)):\n", + " print(' {:4s}: {:3d},'.format(repr(char), char2idx[char]))\n", + "print(' ...\\n}')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "g-LnKyu4dczc" + }, + "outputs": [], + "source": [ + "### Vectorize the songs string ###\n", + "\n", + "'''TODO: Write a function to convert the all songs string to a vectorized\n", + " (i.e., numeric) representation. Use the appropriate mapping\n", + " above to convert from vocab characters to the corresponding indices.\n", + "\n", + " NOTE: the output of the `vectorize_string` function\n", + " should be a np.array with `N` elements, where `N` is\n", + " the number of characters in the input string\n", + "'''\n", + "def vectorize_string(string):\n", + " '''TODO'''\n", + " return np.array([char2idx[x] for x in string])\n", + "\n", + "vectorized_songs = vectorize_string(songs_joined)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IqxpSuZ1w-ub" + }, + "source": [ + "We can also look at how the first part of the text is mapped to an integer representation:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "l1VKcQHcymwb", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3e36859d-be4c-45b4-984c-a10e221d7cb4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "'X:1\\nT:Alex' ---- characters mapped to int ----> [49 22 13 0 45 22 26 67 60 79]\n" + ] + } + ], + "source": [ + "print ('{} ---- characters mapped to int ----> {}'.format(repr(songs_joined[:10]), vectorized_songs[:10]))\n", + "# check that vectorized_songs is a numpy array\n", + "assert isinstance(vectorized_songs, np.ndarray), \"returned result should be a numpy array\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hgsVvVxnymwf" + }, + "source": [ + "### Create training examples and targets\n", + "\n", + "Our next step is to actually divide the text into example sequences that we'll use during training. Each input sequence that we feed into our RNN will contain `seq_length` characters from the text. We'll also need to define a target sequence for each input sequence, which will be used in training the RNN to predict the next character. For each input, the corresponding target will contain the same length of text, except shifted one character to the right.\n", + "\n", + "To do this, we'll break the text into chunks of `seq_length+1`. Suppose `seq_length` is 4 and our text is \"Hello\". Then, our input sequence is \"Hell\" and the target sequence is \"ello\".\n", + "\n", + "The batch method will then let us convert this stream of character indices to sequences of the desired size.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "LF-N8F7BoDRi", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ee83d681-f8d6-4731-be65-cf98f661b68c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Batch function works correctly!\n" + ] + } + ], + "source": [ + "### Batch definition to create training examples ###\n", + "\n", + "def get_batch(vectorized_songs, seq_length, batch_size):\n", + " # the length of the vectorized songs string\n", + " n = vectorized_songs.shape[0] - 1\n", + " # randomly choose the starting indices for the examples in the training batch\n", + " idx = np.random.choice(n - seq_length, batch_size)\n", + "\n", + " '''TODO: construct a list of input sequences for the training batch'''\n", + " input_batch = np.stack([vectorized_songs[i:i+seq_length] for i in idx])\n", + " '''TODO: construct a list of output sequences for the training batch'''\n", + " output_batch = np.stack([vectorized_songs[i+1:i+seq_length+1] for i in idx])\n", + "\n", + "\n", + " # Convert the input and output batches to tensors\n", + " x_batch = torch.tensor(input_batch, dtype=torch.long)\n", + " y_batch = torch.tensor(output_batch, dtype=torch.long)\n", + "\n", + " return x_batch, y_batch\n", + "\n", + "# Perform some simple tests to make sure your batch function is working properly!\n", + "test_args = (vectorized_songs, 10, 2)\n", + "x_batch, y_batch = get_batch(*test_args)\n", + "assert x_batch.shape == (2, 10), \"x_batch shape is incorrect\"\n", + "assert y_batch.shape == (2, 10), \"y_batch shape is incorrect\"\n", + "print(\"Batch function works correctly!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_33OHL3b84i0" + }, + "source": [ + "For each of these vectors, each index is processed at a single time step. So, for the input at time step 0, the model receives the index for the first character in the sequence, and tries to predict the index of the next character. At the next timestep, it does the same thing, but the RNN considers the information from the previous step, i.e., its updated state, in addition to the current input.\n", + "\n", + "We can make this concrete by taking a look at how this works over the first several characters in our text:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "0eBu9WZG84i0", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "27c8d3ce-b762-4f83-86b1-1edff0674b7e" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Step 0\n", + " input: 73 (np.str_('r'))\n", + " expected output: 0 (np.str_('\\n'))\n", + "Step 1\n", + " input: 0 (np.str_('\\n'))\n", + " expected output: 59 (np.str_('d'))\n", + "Step 2\n", + " input: 59 (np.str_('d'))\n", + " expected output: 32 (np.str_('G'))\n", + "Step 3\n", + " input: 32 (np.str_('G'))\n", + " expected output: 32 (np.str_('G'))\n", + "Step 4\n", + " input: 32 (np.str_('G'))\n", + " expected output: 14 (np.str_('2'))\n" + ] + } + ], + "source": [ + "x_batch, y_batch = get_batch(vectorized_songs, seq_length=5, batch_size=1)\n", + "\n", + "for i, (input_idx, target_idx) in enumerate(zip(x_batch[0], y_batch[0])):\n", + " print(\"Step {:3d}\".format(i))\n", + " print(\" input: {} ({:s})\".format(input_idx, repr(idx2char[input_idx.item()])))\n", + " print(\" expected output: {} ({:s})\".format(target_idx, repr(idx2char[target_idx.item()])))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r6oUuElIMgVx" + }, + "source": [ + "## 2.4 The Recurrent Neural Network (RNN) model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m8gPwEjRzf-Z" + }, + "source": [ + "Now we're ready to define and train an RNN model on our ABC music dataset, and then use that trained model to generate a new song. We'll train our RNN using batches of song snippets from our dataset, which we generated in the previous section.\n", + "\n", + "The model is based off the LSTM architecture, where we use a state vector to maintain information about the temporal relationships between consecutive characters. The final output of the LSTM is then fed into a fully connected linear [`nn.Linear`](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html) layer where we'll output a softmax over each character in the vocabulary, and then sample from this distribution to predict the next character.\n", + "\n", + "As we introduced in the first portion of this lab, we'll be using PyTorch's [`nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) to define the model. Three components are used to define the model:\n", + "\n", + "* [`nn.Embedding`](https://pytorch.org/docs/stable/generated/torch.nn.Embedding.html): This is the input layer, consisting of a trainable lookup table that maps the numbers of each character to a vector with `embedding_dim` dimensions.\n", + "* [`nn.LSTM`](https://pytorch.org/docs/stable/generated/torch.nn.LSTM.html): Our LSTM network, with size `hidden_size`.\n", + "* [`nn.Linear`](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html): The output layer, with `vocab_size` outputs.\n", + "\n", + " $\"Drawing\"/$ \n", + "\n", + "\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rlaOqndqBmJo" + }, + "source": [ + "### Define the RNN model\n", + "\n", + "Let's define our model as an `nn.Module`. Fill in the `TODOs` to define the RNN model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "8DsWzojvkbc7" + }, + "outputs": [], + "source": [ + "### Defining the RNN Model ###\n", + "\n", + "'''TODO: Add LSTM and Linear layers to define the RNN model using nn.Module'''\n", + "class LSTMModel(nn.Module):\n", + " def __init__(self, vocab_size, embedding_dim, hidden_size):\n", + " super(LSTMModel, self).__init__()\n", + " self.hidden_size = hidden_size\n", + "\n", + " # Define each of the network layers\n", + " # Layer 1: Embedding layer to transform indices into dense vectors\n", + " # of a fixed embedding size\n", + " self.embedding = nn.Embedding(vocab_size, embedding_dim)\n", + "\n", + " '''TODO: Layer 2: LSTM with hidden_size `hidden_size`. note: number of layers defaults to 1.\n", + " Use the nn.LSTM() module from pytorch.'''\n", + " self.lstm = nn.LSTM(embedding_dim, self.hidden_size, batch_first=True) # TODO\n", + "\n", + " '''TODO: Layer 3: Linear (fully-connected) layer that transforms the LSTM output\n", + " # into the vocabulary size.'''\n", + " self.fc = nn.Linear(self.hidden_size, vocab_size) # TODO\n", + "\n", + " def init_hidden(self, batch_size, device):\n", + " # Initialize hidden state and cell state with zeros\n", + " return (torch.zeros(1, batch_size, self.hidden_size).to(device),\n", + " torch.zeros(1, batch_size, self.hidden_size).to(device))\n", + "\n", + " def forward(self, x, state=None, return_state=False):\n", + " x = self.embedding(x)\n", + "\n", + " if state is None:\n", + " state = self.init_hidden(x.size(0), x.device)\n", + " out, state = self.lstm(x, state)\n", + "\n", + " out = self.fc(out)\n", + " return out if not return_state else (out, state)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IbWU4dMJmMvq" + }, + "source": [ + "The time has come! Let's instantiate the model!" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "MtCrdfzEI2N0", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f5110422-9247-4657-a1e6-4ccc7ba2bb7e" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "LSTMModel(\n", + " (embedding): Embedding(83, 256)\n", + " (lstm): LSTM(256, 1024, batch_first=True)\n", + " (fc): Linear(in_features=1024, out_features=83, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "# Instantiate the model! Build a simple model with default hyperparameters. You\n", + "# will get the chance to change these later.\n", + "vocab_size = len(vocab)\n", + "embedding_dim = 256\n", + "hidden_size = 1024\n", + "batch_size = 8\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "model = LSTMModel(vocab_size, embedding_dim, hidden_size).to(device)\n", + "\n", + "# print out a summary of the model\n", + "print(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-ubPo0_9Prjb" + }, + "source": [ + "### Test out the RNN model\n", + "\n", + "It's always a good idea to run a few simple checks on our model to see that it behaves as expected. \n", + "\n", + "We can quickly check the layers in the model, the shape of the output of each of the layers, the batch size, and the dimensionality of the output. Note that the model can be run on inputs of any length." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "id": "C-_70kKAPrPU", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "cdc73b33-2bdb-47b6-d1fd-ccb6108cd539" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Input shape: torch.Size([32, 100]) # (batch_size, sequence_length)\n", + "Prediction shape: torch.Size([32, 100, 83]) # (batch_size, sequence_length, vocab_size)\n", + "y.shape=torch.Size([32, 100])\n" + ] + } + ], + "source": [ + "# Test the model with some sample data\n", + "x, y = get_batch(vectorized_songs, seq_length=100, batch_size=32)\n", + "x = x.to(device)\n", + "y = y.to(device)\n", + "\n", + "pred = model(x)\n", + "print(\"Input shape: \", x.shape, \" # (batch_size, sequence_length)\")\n", + "print(\"Prediction shape: \", pred.shape, \"# (batch_size, sequence_length, vocab_size)\")\n", + "print(f'{y.shape=}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mT1HvFVUGpoE" + }, + "source": [ + "### Predictions from the untrained model\n", + "\n", + "Let's take a look at what our untrained model is predicting.\n", + "\n", + "To get actual predictions from the model, we sample from the output distribution, which is defined by a torch.softmax over our character vocabulary. This will give us actual character indices. This means we are using a [categorical distribution](https://en.wikipedia.org/wiki/Categorical_distribution) to sample over the example prediction. This gives a prediction of the next character (specifically its index) at each timestep. [`torch.multinomial`](https://pytorch.org/docs/stable/generated/torch.multinomial.html#torch.multinomial) samples over a categorical distribution to generate predictions.\n", + "\n", + "Note here that we sample from this probability distribution, as opposed to simply taking the `argmax`, which can cause the model to get stuck in a repetitive loop.\n", + "\n", + "Let's try this sampling out for the first example in the batch." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "id": "4V4MfFg0RQJg", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2a6ab8d4-a66c-4182-b48a-58887af36f94" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([39, 44, 77, 1, 45, 54, 42, 10, 17, 19, 17, 1, 68, 75, 82, 50, 18,\n", + " 27, 37, 13, 53, 34, 77, 42, 4, 49, 74, 17, 24, 71, 51, 5, 41, 42,\n", + " 32, 67, 57, 32, 32, 67, 38, 70, 11, 16, 77, 64, 48, 41, 68, 82, 47,\n", + " 16, 52, 72, 75, 15, 4, 42, 36, 3, 10, 46, 6, 42, 24, 68, 70, 67,\n", + " 48, 34, 81, 42, 43, 21, 27, 34, 31, 29, 62, 42, 37, 28, 73, 56, 57,\n", + " 71, 57, 73, 23, 68, 16, 30, 43, 12, 19, 17, 6, 47, 42, 38])" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ], + "source": [ + "sampled_indices = torch.multinomial(torch.softmax(pred[0], dim=-1), num_samples=1)\n", + "sampled_indices = sampled_indices.squeeze(-1).cpu().numpy()\n", + "sampled_indices" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LfLtsP3mUhCG" + }, + "source": [ + "We can now decode these to see the text predicted by the untrained model:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "id": "xWcFwPwLSo05", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "be22ab99-546b-486d-deac-19fb5c99c42f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Input: \n", + " ':1/8\\nK:A Mixolydian\\ned|cBcd cBAG|AGEF GABd|cdcB AGEG|ABcd e2ed|!\\ncBcd cBAG|AEAB cdcB|ABAG EDEG|A4 A2'\n", + "\n", + "Next Char Predictions: \n", + " 'NSv T^Q.575 mt|Y6BL1]IvQ#Xs5=pZ\\'PQGlbGGlMo/4viWPm|V4[qt3#QK\".U(Q=molWIzQR9BIFDgQLCrabpbr" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 3000/3000 [01:37<00:00, 30.67it/s]\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Uploading 112 metrics, params and output messages\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 47 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "

Update CSS Variables with JS

content by fetch

content by embed

letter count

letter count

Screen

Tic-Tac