doi
stringlengths 10
10
| chunk-id
int64 0
936
| chunk
stringlengths 401
2.02k
| id
stringlengths 12
14
| title
stringlengths 8
162
| summary
stringlengths 228
1.92k
| source
stringlengths 31
31
| authors
stringlengths 7
6.97k
| categories
stringlengths 5
107
| comment
stringlengths 4
398
⌀ | journal_ref
stringlengths 8
194
⌀ | primary_category
stringlengths 5
17
| published
stringlengths 8
8
| updated
stringlengths 8
8
| references
list |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1706.10295 | 59 | 16
Published as a conference paper at ICLR 2018
D COMPARISON BETWEEN NOISYNET-A3C (FACTORISED AND NON-FACTORISED NOISE) AND A3C
Median score over games 80 70 60 2 5 50 uv Ww c 40 g @ 30 = 20 â AIC 10 â Noisy-Net A3C (Factorised) â = Noisy-Net A3C 0 0 50 100 150 200 250 300 350 Million frames
Figure 5: Comparison of the learning curves of factorised and non-factorised NoisyNet-A3C versus the baseline according to the median human normalised score.
Baseline NoisyNet Mean Median Mean Median Improvement (On median) DQN Dueling A3C A3C (factorised) 319 524 293 293 83 132 80 80 379 633 347 276 123 172 94 99 48% 30% 18% 24 %
Table 2: Comparison between the baseline DQN, Dueling and A3C and their NoisyNet version in terms of median and mean human-normalised scores deï¬ned in Eq. (18). In the case of A3C we inculde both factorised and non-factorised variant of the algorithm. We report on the last column the percentage improvement on the baseline in terms of median human-normalised score.
17
Published as a conference paper at ICLR 2018 | 1706.10295#59 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 61 | NoisyNet-DQN NoisyNet-Dueling alien 2404 + 242 2403 + 78 2027 + 92 1899 + 111 6163 + 1077 5778 + 2189 amidar 924 + 159 1610 + 228 904 + 125 491 + 485 2296 + 154 3537 + 521 assault 3595 + 169 5510 + 483 2879 + 293 3060 + 101 8010 + 381 11231 + 503 asterix 6253 + 154 14328 + 2859 6822 + 181 32478 + 2567 11170 + 5355 28350 + 607 asteroids 1824 + 83 3455 + 1054 2544 + 523 4541 + 311 2220 + 91 86700 + 80459 atlantis 876000 + 15013 923733 + 25798 422700 + 4759 465700 + 4224 902742 + 17087 972175 + 31961 bank heist 455 + 25 1068 + 277 1296 + 20 1033 + 463 1428 + 37 1318 + 37 battle zone 28981 + 1497 36786 + 2892 16411 + 1283 17871 + 5007 40481 + 2161 52262 + 1480 beam rider 10564 + 613 20793 + 284 9214 + 608 11237 + 1582 16298 + 1101 18501 + 662 berzerk 634 + 16 905 + 21 1022 + 151 1235 + 259 1122 + 35 1896 | 1706.10295#61 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 62 | + 608 11237 + 1582 16298 + 1101 18501 + 662 berzerk 634 + 16 905 + 21 1022 + 151 1235 + 259 1122 + 35 1896 + 604 bowling 62+4 71 + 26 37 +2 42+ 11 7246 68 + 6 boxing 87 +1 89+4 91+1 100+ 0 99 +0 100 + 0 breakout 396 + 13 516 + 26 496 + 56 374 +27 200 + 21 263 + 20 centipede 2091 6440 + 1194 4269 + 261 5350 + 432 8282 + 685 4166 + 23 7596 + 1134 chopper command 811 7271 + 473 8893 + 871 5285 + 159 7561 + 1190 7388 + 1024 11477 + 1299 crazy climber 10780 116480 + 896 118305 + 7796 134783 + 5495 139950 + 18190 163335 + 2460 171171 + 2095 defender 2874 18303 + 2611 20525 + 3114 52917 + 3355 $5492 + 3844 37275 + 1572 42253 + 2142 demon attack 152 12696 + 214 36150 + 4646 37085 + 803 37880 + 2093 61033 + 9707 69311 + 26289 double dunk -6+1 1+0 341 3+1 17+7 1+0 enduro i) 835 + 56 1240 | 1706.10295#62 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 63 | 61033 + 9707 69311 + 26289 double dunk -6+1 1+0 341 3+1 17+7 1+0 enduro i) 835 + 56 1240 + 83 o+0 300 + 424 2064 + 81 2013 + 219 fishing derby 4+4 11+2 -7 +30 -38 + 39 3545 57+2 freeway 3140 32 +0 o+0 18 + 13 3440 3440 frostbite 1000 + 258 753 + 101 288 + 20 261 +0 2807 + 1457 2923 + 1519 gopher 11825 + 1444 14574 + 1837 7992 + 672 12439 + 16229 27313 + 2629 38909 + 2229 gravitar 366 + 26 447 + 94 379 + 31 314+ 25 1682 + 170 2209 + 99 hero 15176 + 3870 6246 + 2092 30791 + 246 8471 + 4332 35895 + 1035 31533 + 4970 ice hockey -2+0 -3+0 2+0 341 -O+0 3+1 jamesbond 909 + 223 1235 + 421 509 + 34 188 + 103 1667 + 134 4682 + 2281 kangaroo 8166 + 1512 10944 + 4149 1166 + 76 1604 + 278 14847 + 29 15227 + 243 krull 8343 + 79 8805 + 313 9422 + 980 22849 | 1706.10295#63 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 64 | 1512 10944 + 4149 1166 + 76 1604 + 278 14847 + 29 15227 + 243 krull 8343 + 79 8805 + 313 9422 + 980 22849 + 12175 10733 + 65 10754 + 181 kung fu master 30444 + 1673 36310 + 5093 37422 + 2202 55790 + 23886 30316 + 2397 41672 + 1668 montezuma revenge 243 344 14+ 12 4+3 O+0 57+ 15 ms pacman 2674 + 43 2722 + 148 2436 + 249 3401 + 761 3650 + 445 5546 + 367 name this game 8179 + 551 8181 + 742 7168 + 224 8798 + 1847 9919 + 38 12211 + 251 phoenix 9704 + 2907 16028 + 3317 9476 + 569 50338 + 30396 8215 + 403 10379 + 547 pitfall o+0 o+0 o+0 o+0 o+0 Oo+0 pong 20+ 0 21+0 7+ 19 12+ 11 2140 2140 private eye 2361 + 781 3712 + 161 3781 + 2994 100 +0 227 + 138 279 + 109 qbert 11241 + 1579 15545 + 462 18586 + 574 17896 + 1522 19819 + 2640 27121 + 422 riverraid 7241 + 140 9425 + 705 8135 + 483 | 1706.10295#64 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 65 | + 1579 15545 + 462 18586 + 574 17896 + 1522 19819 + 2640 27121 + 422 riverraid 7241 + 140 9425 + 705 8135 + 483 7878 + 162 18405 + 93 23134 + 1434 road runner 37910 + 1778 45993 + 2709 45315 + 1837 30454 + 13309 64051 + 1106 234352 + 132671 robotank 55+1 SI +5 6+0 36 +3 63+1 64+1 seaquest 4163 + 425 2282 + 361 1744 +0 943 + 41 19595 + 1493 16754 + 6619 skiing -12630 + 202 -14763 + 706 -12972 + 2846 -15970 + 9887 -7989 + 1349 -7550 + 451 solaris 4055 + 842 6088 + 1791 12380 + 519 10427 + 3878 3423 + 152 6522 + 750 space invaders 1283 + 39 2186 + 92 1034 + 49 1126 + 154 1158 + 74 5909 + 1318 star gunner 10250 40934 + 3598 47133 + 7016 49156 + 3882 45008 + 11570 70264 + 2147 75867 + 8623 surround 6 -6+0 -14+2 8+1 1+1 1+3 10+0 tennis -8 847 Oo+0 649 o+0 | 1706.10295#65 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 66 | + 8623 surround 6 -6+0 -14+2 8+1 1+1 1+3 10+0 tennis -8 847 Oo+0 649 o+0 o+0 o+0 time pilot 5229 6167 + 73 7035 + 908 10294 + 1449 11124 + 1753 14094 + 652 17301 + 1200 tutankham 168 218+1 232 + 34 213+ 14 164 + 49 280+ 8 269 + 19 up n down 11693 11652 + 737 14255 + 1658 89067 + 12635 103557 + 51492 93931 + 56045 61326 + 6052 venture 1188 319 + 158 97 + 76 o+0 o+0 1433 + 10 815 + 114 video pinball 17668 429936 + 71110 322507 + 135629 229402 + 153801 294724 + 140514 876503 + 61496 870954 + 135363 wizard of wor 4756 3601 + 873 9198 + 4364 8953 + 1377 12723 + 3420 6534 + 882 9149 + 641 yars revenge 54577 20648 + 1543 23915 + 13939 21596 + 1917 61755 + 4798 43120 + 21466 86101 + 4136 | 1706.10295#66 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 67 | Games alien amidar assault asterix asteroids atlantis bank heist battle zone beam rider berzerk bowling boxing breakout centipede chopper command crazy climber defender demon attack double dunk enduro ï¬shing derby freeway frostbite gopher gravitar hero ice hockey jamesbond kangaroo krull kung fu master montezuma revenge ms pacman name this game phoenix pitfall pong private eye qbert riverraid road runner robotank seaquest skiing solaris space invaders star gunner surround tennis time pilot tutankham up n down venture video pinball wizard of wor yars revenge zaxxon
Human 7128 1720 742 8503 47389 29028 753 37188 16926 2630 161 12 30 12017 7388 35829 18689 1971 -16 860 -39 30 4335 2412 3351 30826 1 303 3035 2666 22736 4753 6952 8049 7243 6464 15 69571 13455 17118 7845 12 42055 -4337 12327 1669 10250 6 -8 5229 168 11693 1188 17668 4756 54577 9173 | 1706.10295#67 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 69 | DQN 2404 ± 242 924 ± 159 3595 ± 169 6253 ± 154 1824 ± 83 876000 ± 15013 455 ± 25 28981 ± 1497 10564 ± 613 634 ± 16 62 ± 4 87 ± 1 396 ± 13 6440 ± 1194 7271 ± 473 116480 ± 896 18303 ± 2611 12696 ± 214 -6 ± 1 835 ± 56 4 ± 4 31 ± 0 1000 ± 258 11825 ± 1444 366 ± 26 15176 ± 3870 -2 ± 0 909 ± 223 8166 ± 1512 8343 ± 79 30444 ± 1673 2 ± 3 2674 ± 43 8179 ± 551 9704 ± 2907 0 ± 0 20 ± 0 2361 ± 781 11241 ± 1579 7241 ± 140 37910 ± 1778 55 ± 1 4163 ± 425 -12630 ± 202 4055 ± 842 1283 ± 39 40934 ± 3598 -6 ± 0 8 ± 7 6167 ± 73 218 ± 1 11652 ± 737 319 ± 158 429936 ± 71110 3601 ± 873 20648 ± 1543 4806 ± 285 | 1706.10295#69 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 70 | NoisyNet-DQN 2403 ± 78 1610 ± 228 5510 ± 483 14328 ± 2859 3455 ± 1054 923733 ± 25798 1068 ± 277 36786 ± 2892 20793 ± 284 905 ± 21 71 ± 26 89 ± 4 516 ± 26 4269 ± 261 8893 ± 871 118305 ± 7796 20525 ± 3114 36150 ± 4646 1 ± 0 1240 ± 83 11 ± 2 32 ± 0 753 ± 101 14574 ± 1837 447 ± 94 6246 ± 2092 -3 ± 0 1235 ± 421 10944 ± 4149 8805 ± 313 36310 ± 5093 3 ± 4 2722 ± 148 8181 ± 742 16028 ± 3317 0 ± 0 21 ± 0 3712 ± 161 15545 ± 462 9425 ± 705 45993 ± 2709 51 ± 5 2282 ± 361 -14763 ± 706 6088 ± 1791 2186 ± 92 47133 ± 7016 -1 ± 2 0 ± 0 7035 ± 908 232 ± 34 14255 ± 1658 97 ± 76 322507 ± 135629 9198 ± 4364 23915 ± 13939 6920 ± 4567 | 1706.10295#70 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 71 | A3C 2027 ± 92 904 ± 125 2879 ± 293 6822 ± 181 2544 ± 523 422700 ± 4759 1296 ± 20 16411 ± 1283 9214 ± 608 1022 ± 151 37 ± 2 91 ± 1 496 ± 56 5350 ± 432 5285 ± 159 134783 ± 5495 52917 ± 3355 37085 ± 803 3 ± 1 0 ± 0 -7 ± 30 0 ± 0 288 ± 20 7992 ± 672 379 ± 31 30791 ± 246 -2 ± 0 509 ± 34 1166 ± 76 9422 ± 980 37422 ± 2202 14 ± 12 2436 ± 249 7168 ± 224 9476 ± 569 0 ± 0 7 ± 19 3781 ± 2994 18586 ± 574 8135 ± 483 45315 ± 1837 6 ± 0 1744 ± 0 -12972 ± 2846 12380 ± 519 1034 ± 49 49156 ± 3882 -8 ± 1 -6 ± 9 10294 ± 1449 213 ± 14 89067 ± 12635 0 ± 0 229402 ± 153801 8953 ± 1377 21596 ± 1917 16544 ± 1513 | 1706.10295#71 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 72 | NoisyNet-A3C 1899 ± 111 491 ± 485 3060 ± 101 32478 ± 2567 4541 ± 311 465700 ± 4224 1033 ± 463 17871 ± 5007 11237 ± 1582 1235 ± 259 42 ± 11 100 ± 0 374 ± 27 8282 ± 685 7561 ± 1190 139950 ± 18190 55492 ± 3844 37880 ± 2093 3 ± 1 300 ± 424 -38 ± 39 18 ± 13 261 ± 0 12439 ± 16229 314 ± 25 8471 ± 4332 -3 ± 1 188 ± 103 1604 ± 278 22849 ± 12175 55790 ± 23886 4 ± 3 3401 ± 761 8798 ± 1847 50338 ± 30396 0 ± 0 12 ± 11 100 ± 0 17896 ± 1522 7878 ± 162 30454 ± 13309 36 ± 3 943 ± 41 -15970 ± 9887 10427 ± 3878 1126 ± 154 45008 ± 11570 1 ± 1 0 ± 0 11124 ± 1753 164 ± 49 103557 ± 51492 0 ± 0 294724 ± 140514 12723 ± 3420 61755 ± 4798 1324 ± 1715 | 1706.10295#72 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 73 | Dueling 6163 ± 1077 2296 ± 154 8010 ± 381 11170 ± 5355 2220 ± 91 902742 ± 17087 1428 ± 37 40481 ± 2161 16298 ± 1101 1122 ± 35 72 ± 6 99 ± 0 200 ± 21 4166 ± 23 7388 ± 1024 163335 ± 2460 37275 ± 1572 61033 ± 9707 17 ± 7 2064 ± 81 35 ± 5 34 ± 0 2807 ± 1457 27313 ± 2629 1682 ± 170 35895 ± 1035 -0 ± 0 1667 ± 134 14847 ± 29 10733 ± 65 30316 ± 2397 0 ± 0 3650 ± 445 9919 ± 38 8215 ± 403 0 ± 0 21 ± 0 227 ± 138 19819 ± 2640 18405 ± 93 64051 ± 1106 63 ± 1 19595 ± 1493 -7989 ± 1349 3423 ± 152 1158 ± 74 70264 ± 2147 1 ± 3 0 ± 0 14094 ± 652 280 ± 8 93931 ± 56045 1433 ± 10 876503 ± 61496 6534 ± 882 43120 ± 21466 13959 ± 613
Table 3: Raw scores across all games with random starts.
18 | 1706.10295#73 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 74 | Table 3: Raw scores across all games with random starts.
18
NoisyNet-Dueling 5778 ± 2189 3537 ± 521 11231 ± 503 28350 ± 607 86700 ± 80459 972175 ± 31961 1318 ± 37 52262 ± 1480 18501 ± 662 1896 ± 604 68 ± 6 100 ± 0 263 ± 20 7596 ± 1134 11477 ± 1299 171171 ± 2095 42253 ± 2142 69311 ± 26289 1 ± 0 2013 ± 219 57 ± 2 34 ± 0 2923 ± 1519 38909 ± 2229 2209 ± 99 31533 ± 4970 3 ± 1 4682 ± 2281 15227 ± 243 10754 ± 181 41672 ± 1668 57 ± 15 5546 ± 367 12211 ± 251 10379 ± 547 0 ± 0 21 ± 0 279 ± 109 27121 ± 422 23134 ± 1434 234352 ± 132671 64 ± 1 16754 ± 6619 -7550 ± 451 6522 ± 750 5909 ± 1318 75867 ± 8623 10 ± 0 0 ± 0 17301 ± 1200 269 ± 19 61326 ± 6052 815 ± 114 870954 ± 135363 9149 ± 641 86101 ± 4136 14874 ± 214
Published as a conference paper at ICLR 2018 | 1706.10295#74 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 75 | Average score 2500 alien ââ pON © 2000 ee teois: 3 % 1500 & @ 1000 £ $ <x 30 0 0 50 100 150 200 Frames (in millions) 1000000 atlantis â DON £00000 -ââ toi 600000 400000 200000 0 0 50 100 150 200 Frames (in millions) 80 bowling 0 sO 100 150 200 Frames (in millions) crazy_climber â pon 140000 120000 100000 80000 60000 Average score 20000 0 oO sO 100 150 200 Frames (in millions) 20 fishing derby â pa Average score 0 sx 100 150 200 Frames (in millions) Average score eh e6 eso 66 os a3 rat os 0 50 100 150 200 Frames (in millions) kung fu_master Average score 0 50 100 150 200 Frames (in millions) â6 itfall @ ~200 S -4 g -400 o ) 600 5 7300 > < -1000 â1200 0 E) 190 150 200 Frames (in millions) 45000 road_runner 40000 2 35000 3 30000 @ 25000 > 20000 3 15000 Z 10000 5000 C) 0 sO 100 150 200 Frames (in millions) 2500 space invaders â vQNn = coed ââ NolsyNet-DQN & 1sa0 & ® 1000 es Zz 500 0 0 x» 100 180 200 Frames (in | 1706.10295#75 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 76 | invaders â vQNn = coed ââ NolsyNet-DQN & 1sa0 & ® 1000 es Zz 500 0 0 x» 100 180 200 Frames (in millions) 250 tutankham â bon ieee â NoisyNet-DQN & 150 S @ 100 £ S x w 0 0 50 100 150 200 Frames (in millions) 35000 yars_revenge @ 20000} ââ DAN 5 oabon NolsyNet-DQN 2 20000 @ 15000 eo Â¥ 10000 = soca 0 0 sO 100 150 200 Frames (in millions) 1600 amidar 1400 ~~ DON 5 2200 âââ_NoisyNet-DOQN Â¥% 1000 &, 800 £ 600 & 400 200 0 0 50 100 150 200 Frames (in millions) 2200 bank_heist â DOQN 000 ie â NoisyNet-DON S 800 uw & 600 n 5 400 = < 200 0 0 50 100 150 200 Frames (in millions) 100 boxing 80 2 6 isyNeEDO! So & 40 o 2 > o oc 5 720 Zz -40 -60 -80 0 50 100 150 200 Frames (in millions) 20000 defender â DON § 25000 _ââ _NoisyNet-DON uv â £7] & 10000 Pcl G > 5000 =z 0 0 50 100 150 200 Frames (in | 1706.10295#76 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 77 | defender â DON § 25000 _ââ _NoisyNet-DON uv â £7] & 10000 Pcl G > 5000 =z 0 0 50 100 150 200 Frames (in millions) 35 freeway a te 5 3 25 NoisyNet-DON ®, 20 15 o 3 10 5 0 0 so 100 150 200 Frames (in millions) ° ice hockey av 2 ° uv wv a i=J 5 > <= -25 0 50 100 150 200 Frames (in millions) 6 montezuma_revenge â DQN g ââ NoisyNet-DQN 4 a uv 3? Fy 2 ti 0 0 50 100 150 200 Frames (in millions) 30 pong â 0QN ad yiet DON S 10 vv wo & 0 5 710 > <= -20 â30 t) 50 100 150 200 Frames (in millions) 60 robotank â DON x0 FS â NoisyNet- S 40 w a &,30 £ g 20 =< 10 f) 0 50 100 150 200 Frames (in millions) 50000 star_gunner â DQN me sopeD ââ NoisyNet-DQN % a0000 & ® 20000 ca] Z 10000 0 0 so 100 1S0 200 Frames (in millions) 14000 up_n_down on BO 7 Net-DQN cyNet- 8 190000 ae â 8000 7] | 1706.10295#77 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 78 | 0 so 100 1S0 200 Frames (in millions) 14000 up_n_down on BO 7 Net-DQN cyNet- 8 190000 ae â 8000 7] 3 cov © 4000 => < 2000 0 0 50 100 150 200 Frames (in millions) 10000 zaxxon â DQN 8000 ââ NolsyNet-DON Average score 0 50 100 150 Frames (in millions) 200 5000 assault â dON ee â NoisyNet-DQN % 3000 & ®@ 2000 o = 1000 0 0 50 100 150 Frames {in millions) 35000 battle zone g 30000} ââ Dan F sc00 NoisyNet-DQN * 20000 2 15000 2 10000 = sooo i 0 50 100 150 Frames (in millions) 00 breakout ââ BQN @ 400 ââ noi ° % 300 & ( 200 $ <= 100 0 0 50 100 150 Frames (in millions) 35000 demon_attack 30000 ââ pa aaa = ate 5 25000 slic vw Fi 20000 2 15000 © 10000 = sooo 0 ft) 50 100 150 Frames {in millions) 1000 frostbite â pon g 800 ââ Noisytet-DON % 600 & © 400 o Z 200 % 50 100 150 Frames (in millions) 1400 jamesbond y 1220 peal eo0N 2 â NoisyNet-! S 1000 ah | 1706.10295#78 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 79 | © 400 o Z 200 % 50 100 150 Frames (in millions) 1400 jamesbond y 1220 peal eo0N 2 â NoisyNet-! S 1000 ah â 3 800 B 900 @ 400 < 200 0 0 50 100 150 Frames (in millions) 3000 ms_pacman â DON 2500 v ; aa 2500 s 1000 <= 500 0 fi 50 100 150 Frames (in millions) 4000 private eye â 0QN g 3000 â NolsyNet-DON B 2000 S © 1000 ev Zz ft) -1000 0 50 100 150 Frames (in millions) 4000 seaquest 3500 ââ DQN § 2000 â NolsyNet-DON % 2500 & 2000 © 1500 g 1000 500 f) 0 50 100 150 Frames (in millions) 2 surround -2 â-DQN LY -3 ââ NoisyNet-DQN S = a ri -5 3 5 g 7 Zz -8 -9 â105 so 100 1s0 Frames (in millions) 400 venture 350 â DOQN 5 300 _ââ_NoisyNet-DQN & 230 % 200 © 150 Es 100 50 0 0 50 100 150 Frames (in millions) 10 vos ° % os & © O04 ov Z 02 0.0 00 fs D2 Oa nie Oe Frames (in millions) 1.0 14000 e 12000 S 10000 % g000 | 1706.10295#79 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 80 | % os & © O04 ov Z 02 0.0 00 fs D2 Oa nie Oe Frames (in millions) 1.0 14000 e 12000 S 10000 % g000 & = 9000 c @ 4000 < 2000 a 0 50 100 150 200 Frames (in millions) 25000 beam _rider â pon £ 20000 ââ NoisyNet-DQN & 15000 & © 10000 o Z 5000 0 0 50 100 150 200 Frames (in millions) soon centipede â 0QN gy 5000 | NoisyNet-DQN o 4 4000 o & 2000 5 2000 < 1000 0 Q 50 100 150 200 Frames (in millions) 5 double_dunk » BQN 5 -s â e . Â¥,-10 $ -15 3 - < -20 -25 0 50 2100 150 200 Frames (in millions) 14000 gopher â pon y 12000 2 Ss & o oa fed $ = 0 50 100 150 200 Frames {in millions) 14000 kangaroo @ 12000 ââ wate toa mm Sy loisyNets! âOn y uv uw 3000 & = 6000 c @ 4000 < 2000 0 0 50 100 150 200 Frames (in millions) 9000 name _this_game 8000 -ââ- DQN © 7000 " S 6000 & 5000 & 4000 & 2000 2 2000 1000 % 50 100 150 200 Frames (in | 1706.10295#80 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 81 | millions) 9000 name _this_game 8000 -ââ- DQN © 7000 " S 6000 & 5000 & 4000 & 2000 2 2000 1000 % 50 100 150 200 Frames (in millions) 16000 qbert 14000 âââ~ 5QN £ 12000 â Nolg % 10000 oa ® a000 © 6000 ve 2 4000 2000 fa o 50 100 150 200 Frames (in millions) -10000 skiing â 0QN iS ~25000 ââ NolsyNet-DQN A -20000 & % ~25000 s 3 Z -30000 35000 50 100 150 200 Frames (in millions) 10 tennis â pon nm NoisyNet-DQN Average score 0 so 100 150 Frames {in millions) 200 400000 video_pinball gy 230000 -ââ oQN = 300000 ââ NoisyNet-DQN & 250000 &, 200000 © 150000 100000 50000 0 o 50 100 150 Frames (in millions) 200 Average score ooor +> Oo M7 © ° N 0.0 0.0 0.2 o4 0.6 os 1.0 Frames (in millions) 4000 asteroids 3500 ââ~ DON s 3000 ââ~_ NoisyNet-OQN &% 2500 ov & 2000 © 1500 1000 500 0 ° 50 100 150 200 Frames (in millions) 900 berzerk 300 â 2 700 | 1706.10295#81 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 82 | ââ~_ NoisyNet-OQN &% 2500 ov & 2000 © 1500 1000 500 0 ° 50 100 150 200 Frames (in millions) 900 berzerk 300 â 2 700 § 600 @ 500 D400 o 300 Z 200 100 0 ° 50 100 150 200 Frames (in millions) 000 chopper_command 7000 ââ OQN £ 6000 â NoisyNet-OQN % 5000 o & 4000 © 3000 £ 2000 1000 0 ° 50 100 150 200 Frames (in millions) 1400 enduro iy 1700 No|syNet-OQN ââ Nols: rm 5 1000 ud & ® 300 600 5 2 400 =< 200 Q ° 50 100 150 200 Frames (in millions) 500 gravitar â 0QN & 400 ââ NoisyNet-OQN % 300 ® © 200 a Z 100 t) ° 50 100 150 200 Frames [in millions) 9000 krull 3000 ââ 2 7000 § sooo wv $ce | 5 3000 = 2000 1000 0 ° 50 100 150 200 Frames (in millions) 18000 phoenix 16000 -ââ-DQN @ 14000 ââ NoisyNet-O0N; & 12000 & so00 c & 6000 Zz 4000 2000 % 50 100 150 200 Frames (in millions) 10000 riverraid 2 So vy v o o c a > 4 ° 50 100 150 200 Frames (in millions) 6000 | 1706.10295#82 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 83 | Zz 4000 2000 % 50 100 150 200 Frames (in millions) 10000 riverraid 2 So vy v o o c a > 4 ° 50 100 150 200 Frames (in millions) 6000 solaris â 0QN ae â NolsyNet-OON & 4000 uw vo & 3000 v 2000 = 1000 Q ° 50 100 150 200 Frames (in millions) go00 time_pilot 7a99. ââ OQN mn ~NoisyNet-OQN ° 50 100 150 Frames [in millions) 200 wizard_of wor â BQN â NoisyNet-OQN Average score ° 50 100 150 200 Frames (in millions) 1.0 » 0.8 ° 4 0.6 S © 0.4 ov 202 0. $0 02 04 #06 O8 10 Frames (in millions) | 1706.10295#83 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 85 | alien ~ r=3 r=9 ° â Dueling ~~ NolsyNet-Dueling 6000 2 5 S000 & 4000 & 3 2000 2000 > = 1000 0 0 50 190 150 200 Frames (in millions) 1cosc00 atlantis % 800000 $ â 600000 & © 400000 2 $ < 200000 0 0 50 100 150 200 Frames (in millions) 2 Ss a uv oa cc] £ $ < 0 Eo) 100 150 200 Frames (in millions) 180000 crazy climber â Dueling ee â NoisyNet-Dj $ 140000 â Â¥ 120000 g 3 100000 < s0000 60000 0 50 100 150 200 Frames (in millions) Py fishing derby 4 ° S âuw o a [ oe 2 < 0 50 100 150 200 Frames (in millions) 0 50 100 150 200 Frames (in millions) kung fu_master 45000 » 40000 â Dueling ; 5 35000 NoisyNet-Dueling & 3000 2 25000 $ 20000 = 5000 10000 0 50 190 150 200 Frames (in millions) ° itfall ~200 i 8 -400 » & -600 4 -800 > = -1000 -1200 50 100 150 200 Frames (in millions) 350000 road_runner y 200000 ââ Dueling - 5 2 NoisyNet-Dueling & 150000 Â¥ | 1706.10295#85 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 86 | -1000 -1200 50 100 150 200 Frames (in millions) 350000 road_runner y 200000 ââ Dueling - 5 2 NoisyNet-Dueling & 150000 Â¥ 100000 = sooco [) 0 * 100 150 200 Frames (in millions) 6000 space_invaders â Dueling g 500 NoisyNet-Dueling & 4000 a 3000 £ 3 2000 < 1000 0 0 50 100 150 200 Frames (in millions) 200 tutankham â Dueling 250 f â § 200 a . 7] $150 2 g 100 < sa 0 0 50 100 150 200 Frames (in millions) agonal yars_ revenge t) 50 100 150 200 Frames (in millions) as00 amidar 12000 assault â Dueling ââ Dueling Â¥ a NolsyNet-Du 4 ââ NoisyNet-Duelin 8 8 8000 ¢ © 6000 Bone © 2000 © 1000 9 = 599 < 2000 0 0 0 50 100 150 200 0 50 100 150 200 Frames (in millions) Frames (in millions) 1400 bank _heist 0000 battle zone â Dueling 2 paces isyNet-Oueling § 8 40000 ââ â & & 30000 8 5 20000 < < 10000 0 0 50 100 150 200 0 50 100 1s0 200 Frames (in millions) Frames (in millions) 100 boxin 300 breakout | 1706.10295#86 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 87 | 30000 8 5 20000 < < 10000 0 0 50 100 150 200 0 50 100 1s0 200 Frames (in millions) Frames (in millions) 100 boxin 300 breakout Dueling 20 Dueling s 80 NoisyNet-Dueling g â _ NoisyNet-Oueling 200 a 60 & cy @ 150 @ 40 ia g & 100 =z 2 Zz 50 C) 0 C) 50 100 150 200 t) 50 100 150 200 Frames (in millions) Frames (in millions) 45000 defender 80000 demon _attack 40000 ââ Dueling 70000 ~~ Dueling § 35000 NgisyNet-O g 60000 ââ _NoisyNet-ueling g 30000 soo00 g 25000 @ aspen £ ® 30000 5 15000 c 2 10000 zB 20000 5000 10000 0 0 ft) 50 100 150 200 0 50 100 150 200 Frames (in millions) Frames (in millions) 35 4000 frostbite e 30 6 25 hae ra 20 @ 15 ry £10 <5 C) fi) 50 100 150 200 0 50 100 150 200 Frames (in millions) Frames {in millions) â ice_hockey 6000 jamesbond ââ Duelin: â Duelin go 7 2 . y 3000 ree] 5S oa Wy ry 4 g -2 g 4000 vo .. g-4 6 > | 1706.10295#87 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 88 | jamesbond ââ Duelin: â Duelin go 7 2 . y 3000 ree] 5S oa Wy ry 4 g -2 g 4000 vo .. g-4 6 > -8 ery -12 0 50 100 150 200 0 50 100 150 200 Frames (in millions) Frames (in millions) 60 montezuma_revenge 5500 ms_pacman ee Ces Dueling 2 â NoisyNet-Dueling 8 40 uu $0 c G20 > <10 0 (i) 50 100 150 200 t) 50 100 150 200 Frames (in millions) Frames (in millions) 30 pong 400 private â _Duelin â Dueling % NoisyNet-Dueling gy 300 noisyiNet-Dueling S 10 S 200 â â Fs ° Fs 100 5-10 5 0 > > < -20 < -100 -30 -200 0 50 100 150 200 0 50 100 1s0 200 Frames (in millions) Frames (in millions) 70 robotank 20000 seaquest 60 ââ Dueliny â Dueling 5 50 or? £ sso00 ââ NoisyNet-Oueling & 40 a 4 x Â¥ 10000 § 5 3/20 £ sooo Zo < t) C) t) 50 100 150 200 C) 50 100 150 200 Frames (in millions) Frames (in millions) | 1706.10295#88 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 89 | 10000 § 5 3/20 £ sooo Zo < t) C) t) 50 100 150 200 C) 50 100 150 200 Frames (in millions) Frames (in millions) 80000 star_gunner 0 surround 70000 ââ Dueling 4 2 â_Nals 5 60000 & 5 y % S0000 hy Y 40000 @ 0 © 30000 i $ 20000 S -s < s0000 - t) -10 fi) 50 100 150 200 ft) 50 100 150 200 Frames (in millions) Frames (in millions) 140000 up_n_down 1400 venture y 120000 -ââ Dueling ala y 1200 ââ NoisyNet-Oueli 5 1 joisy! jueling 5 1000 a a ra 80000 Fa 800 = 60000 B 600 © 40000 2 400 < 20000 = 200 C) 0 fi) 50 100 150 200 f) 50 100 150 200 Frames (in millions) Frames (in millions) 16000 Zaxxon Lo 14000 ââ Dueling £ 12000 â gos & 210000 4 06 ov Â¥, 8000 8 5 Cn) eee > 4000 > 02 = so00 =z C) 0.0 f) 50 100 150 200 00 O02 O04 O06 O8 10 Frames (in millions) Frames (in millions) asterix ââ Dueling ~~ NoisyNet-Dueling 0 | 1706.10295#89 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 90 | 100 150 200 00 O02 O04 O06 O8 10 Frames (in millions) Frames (in millions) asterix ââ Dueling ~~ NoisyNet-Dueling 0 50 100 150 Frames {in millions) 18000 beam _rider 16000 ââ Dueling © 14000 ââ_ NoisyNet-Duelin & 12000 @ 10000 aeons ol ee Z 4000 2000 0 0 50 100 150 Frames (in millions) 9000 centipede 8000 _ââ Bueling ov ââ 8 7000 NoisyNet-Dueling & so00 c @ 4000 < 3000 2000 0 50 100 150 Frames (in millions) 25 double_ dunk 20 â Ndi: 2 ° 9 a & 3 i po $ < o 50 100 150 Frames (in millions) gopher â Dueling ââ NoisyNet-Oueling 0 50 100 150 Frames (in millions) 16000 kangaroo y 14009 5 12000 Not % 10000 © 3000 © 6000 ov 2 4000 2000 0 (a 50 100 150 Frames (in millions) 12000 name _this_game 11000 .âââ Dueling £ 10000 & 9000 © 3000 £ 7000 2 6000 5000 4000 0 50 100 150 Frames (in millions) 30000 qbert â Dueling p 25000 Noisy & 20000 ra iat & 10000 = sp00 0 0 50 100 150 Frames (in millions) 5000 | 1706.10295#90 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 91 | (in millions) 30000 qbert â Dueling p 25000 Noisy & 20000 ra iat & 10000 = sp00 0 0 50 100 150 Frames (in millions) 5000 skiing 0000 0 50 100 150 Frames {in millions) 0 tennis Average score iL ° 50 100 150 Frames (in millions) 900000 video pinball 800000 ââ Dueling © 700000 ââ NeisyNet-Dueling & soo000 @ 500000 © 400000 5 200000 2 200000 100000 0 50 100 150 Frames (in millions) Average score oo 2g 2 bo ® fe Us bd i) ° Frames (in millions) ââ Dueling cr tent, â2 uaa if i} â4 eT @ 14000 ââ_ NoisyNet-Duell 0.2 o4 0.6 o8 140000 asteroids q 120000 ââ Dueling 5 100000 âââ~ NolsyNet-Dueling ww ® 80000 60000 ® 40000 <X 20000 0 200 ° 50 100 150 200 Frames (in millions) 2000 berzerk 1800 ââ Oueling 2 1600 ââ_ NoisyNet-Dueling $ 1400 sis 5 800 Zz 600 400 200 200 ° 50 100 150 200 Frames (in millions) 12000 chopper_command â Dueling 20000 â _NoisyNet-Duelin § 3000 my : uv | 1706.10295#91 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 92 | 400 200 200 ° 50 100 150 200 Frames (in millions) 12000 chopper_command â Dueling 20000 â _NoisyNet-Duelin § 3000 my : uv FE 6000 & 4000 < 2000 0 200 ° 50 100 150 200 Frames (in millions) 2000 enduro ~~, Dueling = 1500 ; Vv uv Â¥ 1000 5 > 500 4 () 200 ° 50 100 150 200 Frames (in millions) 2500 gravitar â Dueling @ 2000 Noicyn ° & 1500 & © 1000 vo Z 500 0 200 ° 50 100 150 200 Frames (in millions) 11000 krull » 10000 8 9000 2 8000 # @ 7000 @ 6000 = sooo 200 baht 50 100 150 200 Frames (in millions) 10000 phoenix 9000 ââ Dueling 2 so00 Dueling $ 7000 & S000 5 4000 Zz moo 2000 1000 200 ° 50 100 150 200 Frames (in millions) 25000 riverraid â Dueling @ 20000 Noisy et, " ° & 15000 & © 10000 ov Z 5000 0 200 ° 50 100 150 200 Frames (in millions) 6000 solaris â Dueling y 3000 NoisyhNet: Dualing § 4000 & 00 o 2000 1000 0 200 ° 50 100 150 200 Frames {in millions} 18000 time_pilot 16000 ââ Dueling 200 ° 50 100 150 200 Frames | 1706.10295#92 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 95 | 2000 alien 1800 w 1600 S 1400 wv 1200 > 1000 ~~ ® 800 <= 600 NoisyNet-A3C and A3C 50 100 150 200 250 300 Frames (in millions) 500000 atlantis 400000 2 fe uh ROO aae NoisyNet-A3C > § 200000 A3e 2 = 100000 ° 50 100 150 200 250 300 Frames (in millions) 45 bowling NoisyNet-A3C 40 | A3BC 235 & 30 3,25 £20 2415 10 a 50 100 150 200 250 300 Frames (in millions) 140000 crazy_climber 120000 = 100000 a 80000 = 60000 2 40000 20000 nd 50 100 150 200 250 300 Frames (in millions) 20 fishing derby NoisyNet-A3C o | ABC 2 ° ra) oa a od v2 = = a 50 100 150 200 250 300 Frames (in millions) 35000 hero NoisyNet-A3C 30000 A3c es 5 25000 a 20000 = 15000 = 10000 5000 ° 50 100 150 200 250 300 Frames (in millions) 70000 kung _fu_master NoisyNet-A3C 60000 A3c £ 50000 ai 40000 = 30000 2 20000 10000 c 50 100 150 200 250 300 Frames (in millions) o tfall -50 2 S -100 w ¥ | 1706.10295#95 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 96 | £ 50000 ai 40000 = 30000 2 20000 10000 c 50 100 150 200 250 300 Frames (in millions) o tfall -50 2 S -100 w Â¥ -150 £ @ â200 = -~250 NoisyNet-A3C BOO | A3BC ~ 50 100 150 200 250 300 Frames (in millions) 50000 road_runner « 40000 2 ° cA 30000 y a © 20000 $ < 10000 NoisyNet-A3C . A3C 50 100 150 200 250 300 Frames (in millions) 1200 space_invaders NoisyNet-A3C 1000 | ABC wy S 800 wo ®% 600 Cc g 400 =z 200 ° 50 100 150 200 250 300 Frames (in millions) 250 tutankham 200 2 } o R150 i ov b=a] © 100 g =< 50 NoisyNet-A3C o | ABC 50 100 150 200 250 300 Frames (in millions) 70000 yars_revenge NoisyNet-A3C 60000 el ASC = 50000 a 40000 = 30000 2 20000 10000 ° 50 100 150 200 250 300 Frames (in millions) 1000 amidar Pa 800 S ; &% 600 ow Da ec 400 o = <= 200 ° 50 100 150 200 250 300 Frames (in millions) 1400 bank_heist 1200 oy = 1000 Â¥ â» | 1706.10295#96 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 97 | &% 600 ow Da ec 400 o = <= 200 ° 50 100 150 200 250 300 Frames (in millions) 1400 bank_heist 1200 oy = 1000 Â¥ â» 8s00 wo = 600 2 400 = 200 Ls 50 100 150 200 250 300 Frames (in millions) 100 boxing 80 2 Ss 60 iva) m 40 [4 v 20 = ° -20 50 100 150 200 250 300 Frames (in millions) 60000 defender 50000 & 40000 rr) aes ® 20000 = = 10000 °o 50 100 150 200 250 300 Frames (in millions) 25 freeway 20 (4 S Bis MaWenat ryt tt eg Da © 10 2 <os o . _ 50 100 150 200 250 300 Frames (in millions) ~2 ice_hockey -4 2 S a -6 wv a ec -8 2 = _10 -12 50 100 150 200 250 300 Frames (in millions) 16 montezuma_revenge 14 12 8 10 2 8 £6 a4 ft Stine 50 100 150 200 250 300 Frames (in millions) Average Score 50 100 150 200 250 300 Frames (in millions) robotank &S ° Average Score RPRPNN Ww ovuow ow 50 100 150 200 250 300 Frames (in millions) 60000 star_gunner 50000 40000 30000 20000 10000 Average Score Ls | 1706.10295#97 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 98 | Ww ovuow ow 50 100 150 200 250 300 Frames (in millions) 60000 star_gunner 50000 40000 30000 20000 10000 Average Score Ls 50 100 150 200 250 300 Frames (in millions) 140000 up_n_down 120000 100000 80000 60000 f 40000 20000 ° Average Score 50 100 150 200 250 300 Frames (in millions) 18000 ZAXKON 16000 14000 12000 Average Score 6 3 50 100 150 200 250 300 Frames (in millions) . \ Average Score hw RF N $333 ---e-) 25000 20000 Average Score 5 6 u Oo 8 8 8 o 6 66 \ ° 6 6 & oo 6 N ° ° Y Average Score 8 35000 30000 25000 20000 15000 10000 5000 âore â & a Averag Average Score 6 8 $ 8 $8 8 8 3500 Average Score BERR \ 5000 4000 3000 2000 1000 Average Score -â1000 1800 we be pe 883 ooo Average Score r-) 8§338 co ° Average Score N 0.06 0.04 0.02 0.00 -0.02 Average Score â-0.04 0.06 oe assault 50 100 150 200 250 300 Frames (in millions) battle zone 50 100 150 200 250 300 Frames (in millions) breakout 50 100 150 200 250 300 Frames (in millions) demon_attack 50 100 150 200 250 300 Frames | 1706.10295#98 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 99 | battle zone 50 100 150 200 250 300 Frames (in millions) breakout 50 100 150 200 250 300 Frames (in millions) demon_attack 50 100 150 200 250 300 Frames (in millions) frostbite | 50 100 150 200 250 300 Frames (in millions) jamesbond 50 100 150 200 250 300 Frames (in millions) ms_pacman 50 100 150 200 250 300 Frames (in millions) private_eye 50 100 150 200 250 300 Frames (in millions) seaquest 50 100 150 200 250 300 Frames (in millions) surround 50 100 150 200 250 300 Frames (in millions) venture 50 100 150 200 250 300 Frames (in millions) e 5 asterix e 50 100 150 200 250 300 Frames (in millions) 12000 beam _rider 10000 2 S 8000 a) a 6000 Fd ®@ 4000 2 = 2000 id 50 100 150 200 250 300 Frames (in millions) 9000 centipede 8000 x ° ° ° h ° ° Average Score 86 $8 ae) ae) ° ° 2000 50 100 150 200 250 300 Frames (in millions) 5 double_dunk e ° co A -5 ov o> fe -10 av = <-4a5 -â20 50 100 150 200 250 300 Frames (in millions) 25000 gopher wv 20000 °c # 15000 a a © 10000 ov = = 5000 q | 50 100 | 1706.10295#99 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 100 | -â20 50 100 150 200 250 300 Frames (in millions) 25000 gopher wv 20000 °c # 15000 a a © 10000 ov = = 5000 q | 50 100 150 200 250 300 Frames (in millions) 1800 kangaroo 1600 Pa 1400 : â S 1200 a 1000 2 800 y 600 =< 400 200 0 50 100 150 200 250 300 Frames (in millions) 10000 name_this_game 93000 ® 8000 & 7000 & 6000 & 5000 = 4000 3000 nai 50 100 150 200 250 300 Frames (in millions) 20000 qbert ~ 15000 Co v w %, 10000 Ss o = 5000 °o 50 100 150 200 250 300 Frames (in millions) ~10000 skiing w -â15000 ee °o i -20000 v a © -25000 ov > <= -30000 â35000 50 100 150 200 250 300 Frames (in millions) ° tennis ov £ o vy âw v a £ S <= 50 100 150 200 250 300 Frames (in millions) 300000 video_pinball 250000 2 S 200000 w m 150000 ® 100000 > < 50000 50 100 150 200 250 300 Frames (in millions) cy a a oo as 1. asteroids 8 8 3500 3000 2500 2000 1500 1000 Average Score 50 100 150 200 250 300 Frames {in millions) berzerk 1400 1200 1000 Average Score 200 50 | 1706.10295#100 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.10295 | 101 | oo as 1. asteroids 8 8 3500 3000 2500 2000 1500 1000 Average Score 50 100 150 200 250 300 Frames {in millions) berzerk 1400 1200 1000 Average Score 200 50 100 150 200 250 300 Frames {in millions) chopper_command Average Score $88$3a8 $888888 3 ° 50 100 150 200 250 300 Frames (in millions) enduro Average Score ye Nw ew g¢g:egeg oo 6 6 -) 50 100 150 200 250 300 Frames (in millions) 400 gravitar 350 300 250 200 150 100 50 âore a oa Averag 50 100 150 200 250 300 Frames (in millions) 30000 krull 25000 2 S 20000 Sc §, 15000 10000 5000 Avera 50 100 150 200 250 300 Frames {in millions) 60000 phoenix 50000 40000 30000 20000 Average Score 10000 ° 50 100 150 200 250 300 Frames {in millions) riverraid 88888388 88888888 Average Score 8 ° 50 100 150 200 250 300 Frames {in millions) solaris 888588 $888888 Average Score hw N Ww ees } ecco 50 100 150 200 250 300 Frames {in millions) time_pilot Average Score 50 100 150 200 250 300 Frames (in millions) wizard_of_wor Average Score 50 100 150 200 250 300 Frames {in | 1706.10295#101 | Noisy Networks for Exploration | We introduce NoisyNet, a deep reinforcement learning agent with parametric
noise added to its weights, and show that the induced stochasticity of the
agent's policy can be used to aid efficient exploration. The parameters of the
noise are learned with gradient descent along with the remaining network
weights. NoisyNet is straightforward to implement and adds little computational
overhead. We find that replacing the conventional exploration heuristics for
A3C, DQN and dueling agents (entropy reward and $\epsilon$-greedy respectively)
with NoisyNet yields substantially higher scores for a wide range of Atari
games, in some cases advancing the agent from sub to super-human performance. | http://arxiv.org/pdf/1706.10295 | Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, Shane Legg | cs.LG, stat.ML | ICLR 2018 | null | cs.LG | 20170630 | 20190709 | [
{
"id": "1703.07608"
},
{
"id": "1608.05081"
},
{
"id": "1509.02971"
},
{
"id": "1703.01310"
},
{
"id": "1601.04114"
},
{
"id": "1703.05449"
},
{
"id": "1704.02798"
},
{
"id": "1706.01905"
}
] |
1706.08612 | 0 | 8 1 0 2
y a M 0 3 ] D S . s c [
2 v 2 1 6 8 0 . 6 0 7 1 : v i X r a
# VoxCeleb: a large-scale speaker identiï¬cation dataset
Arsha Nagraniâ , Joon Son Chungâ , Andrew Zisserman
# Visual Geometry Group, Department of Engineering Science, University of Oxford, UK {arsha,joon,az}@robots.ox.ac.uk
# Abstract
Most existing datasets for speaker identiï¬cation contain sam- ples obtained under quite constrained conditions, and are usu- ally hand-annotated, hence limited in size. The goal of this pa- per is to generate a large scale text-independent speaker identi- ï¬cation dataset collected âin the wildâ.
We make two contributions. First, we propose a fully au- tomated pipeline based on computer vision techniques to create the dataset from open-source media. Our pipeline involves ob- taining videos from YouTube; performing active speaker veriï¬- cation using a two-stream synchronization Convolutional Neu- ral Network (CNN), and conï¬rming the identity of the speaker using CNN based facial recognition. We use this pipeline to cu- rate VoxCeleb which contains hundreds of thousands of âreal worldâ utterances for over 1,000 celebrities. | 1706.08612#0 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 1 | Our second contribution is to apply and compare various state of the art speaker identiï¬cation techniques on our dataset to establish baseline performance. We show that a CNN based architecture obtains the best performance for both identiï¬cation and veriï¬cation. Index Terms: large-scale, dataset, convolutional neural network
# 1. Introduction
Speaker recognition under noisy and unconstrained conditions is an extremely challenging topic. Applications of speaker recognition are many and varied, ranging from authentication in high-security systems and forensic tests, to searching for per- sons in large corpora of speech data. All such tasks require high speaker recognition performance under âreal worldâ con- ditions. This is an extremely difï¬cult task due to both extrinsic and intrinsic variations; extrinsic variations include background chatter and music, laughter, reverberation, channel and micro- phone effects; while intrinsic variations are factors inherent to the speaker themself such as age, accent, emotion, intonation and manner of speaking, amongst others [1]. | 1706.08612#1 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 2 | Deep Convolutional Neural Networks (CNNs) have given rise to substantial improvements in speech recognition, com- puter vision and related ï¬elds due to their ability to deal with real world, noisy datasets without the need for handcrafted fea- tures [2, 3, 4]. One of the most important ingredients for the success of such methods, however, is the availability of large training datasets.
Unfortunately, large-scale public datasets in the ï¬eld of speaker identiï¬cation with unconstrained speech samples are lacking. While large-scale evaluations are held regularly by the National Institute of Standards in Technology (NIST), these datasets are not freely available to the research community. The only freely available dataset curated from multimedia is the
Speakers in the Wild (SITW) dataset [5], which contains speech samples of 299 speakers across unconstrained or âwildâ condi- tions. This is a valuable dataset, but to create it the speech sam- ples have been hand-annotated. Scaling it further, for example to thousands of speakers across tens of thousands of utterances, would require the use of a service such as Amazon Mechanical Turk (AMT). In the computer vision community AMT like ser- vices have been used to produce very large-scale datasets, such as ImageNet [6]. | 1706.08612#2 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 3 | This paper has two goals. The ï¬rst is to propose a fully automated and scalable pipeline for creating a large-scale âreal worldâ speaker identiï¬cation dataset. By using visual active speaker identiï¬cation and face veriï¬cation, our method circum- vents the need for human annotation completely. We use this method to curate VoxCeleb, a large-scale dataset with hun- dreds of utterances for over a thousand speakers. The second goal is to investigate different architectures and techniques for training deep CNNs on spectrograms extracted directly from the raw audio ï¬les with very little pre-processing, and compare our results on this new dataset with more traditional state-of-the-art methods.
VoxCeleb can be used for both speaker identiï¬cation and veriï¬cation. Speaker identiï¬cation involves determining which speaker has produced a given utterance, if this is performed for a closed set of speakers then the task is similar to that of multi- class classiï¬cation. Speaker veriï¬cation on the other hand in- volves determining whether there is a match between a given utterance and a target model. We provide baselines for both tasks.
The dataset can be downloaded from http://www. robots.ox.ac.uk/Ëvgg/data/voxceleb. | 1706.08612#3 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 5 | # 2. Related Works
For a long time, speaker identiï¬cation was the domain of Gaus- sian Mixture Models (GMMs) trained on low dimensional fea- ture vectors [7, 8]. The state of the art in more recent times in- volves both the use of joint factor analysis (JFA) based methods which model speaker and channel subspaces separately [9], and i-vectors which attempt to model both subspaces into a single compact, low-dimensional space [10]. Although state of the art in speaker recognition tasks, these methods all have one thing in common â they rely on a low dimensional representation of the audio input, such as Mel Frequency Cepstrum Coefï¬cients (MFCCs). However, not only does the performance of MFCCs degrade rapidly in real world noise [11, 12], but by focusing only on the overall spectral envelope of short frames, MFCCs may be lacking in speaker-discriminating features (such as pitch information). This has led to a very recent shift from hand- crafted features to the domain of deep CNNs which can be ap- plied to higher dimensional inputs [13, 14] and for speaker iden- tiï¬cation [15]. Essential to this task however, is a large dataset obtained under real world conditions.
â These authors contributed equally to this work. | 1706.08612#5 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 6 | â These authors contributed equally to this work.
Many existing datasets are obtained under controlled con- ditions, for example: forensic data intercepted by police of- ï¬cials [16], data from telephone calls [17], speech recorded live in high quality environments such as acoustic laborato- ries [18, 19], or speech recorded from mobile devices [20, 21]. [22] consists of more natural speech but has been manually pro- cessed to remove extraneous noises and crosstalk. All the above datasets are also obtained from single-speaker environments, and are free from audience noise and overlapping speech.
Datasets obtained from multi-speaker environments include those from recorded meeting data [23, 24], or from audio broad- casts [25]. These datasets usually contain audio samples un- der less controlled conditions. Some datasets contain artiï¬cial degradation in an attempt to mimic real world noise, such as those developed using the TIMIT dataset [19]: NTIMIT, (trans- mitting TIMIT recordings through a telephone handset) and CTIMIT, (passing TIMIT ï¬les through cellular telephone cir- cuits). | 1706.08612#6 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 7 | Table 1 summarises existing speaker identiï¬cation datasets. Besides lacking real world conditions, to the best of our knowl- edge, most of these datasets have been collected with great man- ual effort, other than [25] which was obtained by mapping sub- titles and transcripts to broadcast data.
Name Cond. Free #POL # Utter. ELSDSRâ Clean Speech vo 22 198) MIT Mobile Mobile Devices - 88 7,884 SWB (27 Telephony - 3,114 33,039 POLYCOST [17] Telephony : 133 | 1,285§ ICSI Meeting Corpus Meetings = 33 922 Forensic Comparison [22] Telephony T 352 1.264 ANDOSL [18} Clean speech : 204 33,900 TIMIT T Clean speech - 630 6,300 SITW Multi-media v 299 2,800 NIST SRE 229) Clean speech = 2,000+ * VoxCeleb Multi-media v 1,251 153,516
Table 1: Comparison of existing speaker identiï¬cation datasets. Cond.: Acoustic conditions; POI: Person of Interest; Ut- ter.: Approximate number of utterances. â And its derivatives. â¡Number of telephone calls. â varies by year. | 1706.08612#7 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 8 | 3. Dataset Description VoxCeleb contains over 100,000 utterances for 1,251 celebri- ties, extracted from videos uploaded to YouTube. The dataset is gender balanced, with 55% of the speakers male. The speakers span a wide range of different ethnicities, accents, professions and ages. The nationality and gender of each speaker (obtained from Wikipedia) is also provided.
Videos included in the dataset are shot in a large num- ber of challenging multi-speaker acoustic environments. These include red carpet, outdoor stadium, quiet studio interviews, speeches given to large audiences, excerpts from profession- ally shot multimedia, and videos shot on hand-held devices. Crucially, all are degraded with real world noise, consisting of background chatter, laughter, overlapping speech, room acous- tics, and there is a range in the quality of recording equipment and channel noise. Unlike the SITW dataset, both audio and video for each speaker is released. Table 2 gives the dataset statistics.
# 4. Dataset Collection Pipeline
This section describes our multi-stage approach for collect- ing a large speaker recognition dataset, starting from YouTube videos. Using this fully automated pipeline, we have obtained hundreds of utterances for over a thousand different Persons of | 1706.08612#8 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 10 | Interest (POIs). The pipeline is summarised in Figure 1 left, and key stages are discussed in the following paragraphs: Stage 1. Candidate list of POIs. The ï¬rst stage is to obtain a list of POIs. We start from the list of people that appear in the VGG Face dataset [30] , which is based on an intersection of the most searched names in the Freebase knowledge graph, and the Internet Movie Data Base (IMDB). This list contains 2,622 identities, ranging from actors and sportspeople to en- trepreneurs, of which approximately half are male and the other half female. Stage 2. Downloading videos from YouTube. The top 50 videos for each of the 2,622 POIs are automatically downloaded using YouTube search. The word âinterviewâ is appended to the name of the POI in search queries to increase the likelihood that the videos contain an instance of the POI speaking, and to ï¬lter out sports or music videos. No other ï¬ltering is done at this stage. Stage 3. Face tracking. The HOG-based face detector [32] is used to detect the faces in every frame of the video. Facial landmark positions are detected for each face detection using the regression tree | 1706.08612#10 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 11 | face detector [32] is used to detect the faces in every frame of the video. Facial landmark positions are detected for each face detection using the regression tree based method of [33]. The shot boundaries are detected by comparing colour histograms across consecutive frames. Within each detected shot, face detections are grouped together into face tracks using a position-based tracker. This stage is closely related to the tracking pipeline of [34, 35], but optimised to reduce run-time given the very large number of videos to process. Stage 4. Active speaker veriï¬cation. The goal of this stage is to determine the audio-video synchronisation between mouth motion and speech in a video in order to determine which (if any) visible face is the speaker. This is done by using âSync- Netâ, a two-stream CNN described in [36] which estimates the correlation between the audio track and the mouth motion of the video. This method is able to reject the clips that contain dubbing or voice-over. Stage 5. Face veriï¬cation. Active speaker face tracks are then classiï¬ed into whether they are of the POI or not using the VGG Face CNN. This classiï¬cation network is based on the | 1706.08612#11 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 12 | face tracks are then classiï¬ed into whether they are of the POI or not using the VGG Face CNN. This classiï¬cation network is based on the VGG-16 CNN [3] trained on the VGG Face dataset (which is a ï¬ltered collection of Google Image Search results for the POI name). Veriï¬cation is done by directly using this classiï¬cation score with a high threshold. Discussion. In order to ensure that our system is extremely conï¬dent that a person is speaking (Stage 4), and that they have been correctly identiï¬ed (Stage 5) without any manual interfer- ence, we set very conservative thresholds in order to minimise the number of false positives. Precision-recall curves for both tasks on their respective benchmark datasets [30, 31] are shown in Figure 1 right, and the values at the operating point are given in Table 3. Employing these thresholds ensures that although we discard a lot of the downloaded videos, we can be reason- ably certain that the dataset has few labelling errors. This ensures a completely automatic pipeline that can be scaled up to any number of speakers and utterances (if available) as | 1706.08612#12 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 13 | Elon Musk Download videos |» Face detection A+ Anytime + J i ee see Audio feature Sanersaton wih lo Face tracking extraction âeeee J 1 persia] austere = ; ro Treanfeon Â¥ Bonus How pat Active speaker verification 1 Face verification || VoxCeleb database
1 Elon Musk Download videos |» Face detection A+ Anytime + J i 0.9 ee see Audio feature Sanersaton wih lo Face tracking extraction âeeee J 1 5 08 persia] austere Ss = 2 8 ; ro Treanfeon £07 Â¥ Bonus How pat Active speaker verification 06 âActive speaker verification 1 Face verification Face verification || VoxCeleb database 05 0.5 0.6 0.7 0.8 0.9 1 Recall
Figure 1: Left: Data processing pipeline; Right: Precision-recall curves for the active speaker veriï¬cation (using a 25-frame window) and the face veriï¬cation steps, tested on standard benchmark datasets [30, 31]. Operating points are shown in circles.
required. | 1706.08612#13 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 14 | softmax in order to produce a distribution over the 1,251 differ- ent speakers. Veriï¬cation. For veriï¬cation, feature vectors can be obtained from the classiï¬cation network using the 1024 dimension fc7 vectors, and a cosine distance can be used to compare vec- tors. However, it is better to learn an embedding by training a Siamese network with a contrastive loss [38]. This is better suited to the veriï¬cation task as the network learns to optimize similarity directly, rather than indirectly via a classiï¬cation loss. For the embedding network, the last fully connected layer (fc8) is modiï¬ed so that the output size is 1024 instead of the number of classes. We compare both methods in the experiments. Testing. A traditional approach to handling variable length ut- terances at test time is to break them up into ï¬xed length seg- ments (e.g. 3 seconds) and average the results on each segment to give a ï¬nal class prediction. Average pooling, however al- lows the network to accommodate variable length inputs at test time, as the entire test utterance can be evaluated at once by changing the size of the | 1706.08612#14 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 17 | Our aim is to move from techniques that require traditional hand-crafted features, to a CNN architecture that can choose the features required for the task of speaker recognition. This allows us to minimise the pre-processing of the audio data and hence avoid losing valuable information in the process. Input features. All audio is ï¬rst converted to single-channel, 16-bit streams at a 16kHz sampling rate for consistency. Spec- trograms are then generated in a sliding window fashion using a hamming window of width 25ms and step 10ms. This gives spectrograms of size 512 x 300 for 3 seconds of speech. Mean and variance normalisation is performed on every frequency bin of the spectrum. This normalisation is crucial, leading to an al- most 10% increase in classiï¬cation accuracy, as shown in Ta- ble 7. No other speech-speciï¬c preprocessing (e.g. silence re- moval, voice activity detection, or removal of unvoiced speech) is used. These short time magnitude spectrograms are then used as input to the CNN. Architecture. Since speaker identiï¬cation under a closed set can be treated as a multiple-class classiï¬cation problem, we base our architecture on | 1706.08612#17 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 18 | Architecture. Since speaker identiï¬cation under a closed set can be treated as a multiple-class classiï¬cation problem, we base our architecture on the VGG-M [37] CNN, known for good classiï¬cation performance on image data, with modiï¬cations to adapt to the spectrogram input. The fully connected fc6 layer of dimension 9 à 8 (support in both dimensions) is replaced by two layers â a fully connected layer of 9 à 1 (support in the fre- quency domain) and an average pool layer with support 1 à n, where n depends on the length of the input speech segment (for example for a 3 second segment, n = 8). This makes the net- work invariant to temporal position but not frequency, and at the same time keeps the output dimensions the same as those of the original fully connected layer. This also reduces the number of parameters from 319M in VGG-M to 67M in our network, which helps avoid overï¬tting. The complete CNN architecture is speciï¬ed in Table 4. Identiï¬cation. Since identiï¬cation is treated as a simple classi- ï¬cation task, the output of the last layer is fed into a 1,251-way | 1706.08612#18 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 19 | Layer conv1 mpool1 conv2 mpool2 conv3 conv4 conv5 mpool5 fc6 apool6 fc7 fc8 Support 7Ã7 3Ã3 5Ã5 3Ã3 3Ã3 3Ã3 3Ã3 5Ã3 9Ã1 1Ãn 1Ã1 1Ã1 Filt dim. 1 - 96 - 256 384 256 - 256 - 4096 1024 # ï¬lts. 96 - 256 - 384 256 256 - 4096 - 1024 1251 Stride 2Ã2 2Ã2 2Ã2 2Ã2 1Ã1 1Ã1 1Ã1 3Ã2 1Ã1 1Ã1 1Ã1 1Ã1 Data size 254Ã148 126Ã73 62Ã36 30Ã17 30Ã17 30Ã17 30Ã17 9Ã8 1Ã8 1Ã1 1Ã1 1Ã1
Table 4: CNN architecture. The data size up to fc6 is for a 3- second input, but the network is able to accept inputs of variable lengths. | 1706.08612#19 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 20 | Table 4: CNN architecture. The data size up to fc6 is for a 3- second input, but the network is able to accept inputs of variable lengths.
Implementation details and training. Our implementation is based on the deep learning toolbox MatConvNet [39] and trained on a NVIDIA TITAN X GPU. The network is trained using batch normalisation [40] and all hyper-parameters (e.g. weight decay, learning rates) use the default values provided with the toolbox. To reduce overï¬tting, we augment the data by taking random 3-second crops in the time domain during train- ing. Using a ï¬xed input length is also more efï¬cient. For veri- ï¬cation, the network is ï¬rst trained for classiï¬cation (excluding the test POIs for the veriï¬cation task, see Section 6), and then
all ï¬lter weights are frozen except for the modiï¬ed last layer and the Siamese network trained with contrastive loss. Choos- ing good pairs for training is very important in metric learning. We randomly select half of the negative examples, and the other half using Hard Negative Mining, where we only sample from the hardest 10% of all negatives.
# 6. Experiments | 1706.08612#20 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 21 | # 6. Experiments
This section describes the experimental setup for both speaker identiï¬cation and veriï¬cation, and compares the performance of our devised CNN baseline to a number of traditional state of the art methods on VoxCeleb.
# 6.1. Experimental setup
Speaker identiï¬cation. For identiï¬cation, the training and the testing are performed on the same POIs. From each POI, we reserve the speech segments from one video for test. The test video contains at least 5 non-overlapping segments of speech. For identiï¬cation, we report top-1 and top-5 accuracies. The statistics are given in Table 5. Speaker veriï¬cation. For veriï¬cation, all POIs whose name starts with an âEâ are reserved for testing, since this gives a good balance of male and female speakers. These POIs are not used for training the network, and are only used at test time. The statistics are given in Table 6.
Two key performance metrics are used to evaluate system performance for the veriï¬cation task. The metrics are similar to those used by existing datasets and challenges, such as NIST SRE12 [29] and SITW [5]. The primary metric is based on the cost function Cdet | 1706.08612#21 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 22 | Cdet = Cmiss à Pmiss à Ptar + Cf a à Pf a à (1 â Ptar) (1)
where we assume a prior target probability Ptar of 0.01 and equal weights of 1.0 between misses Cmiss and false alarms Cf a. The primary metric, Cmin det , is the minimum value of Cdet for the range of thresholds. The alternative performance mea- sure used here is the Equal Error Rate (EER) which is the rate at which both acceptance and rejection errors are equal. This measure is commonly used for identity veriï¬cation systems.
Set Dev Test Total # POIs 1,251 1,251 1,251 # Vid. / POI 17.0 1.0 1.0 # Utterances 145,265 8,251 153,516
Table 5: Development and test set statistics for identiï¬cation.
Set Dev Test Total # POIs 1,211 40 1,251 # Vid. / POI 18.0 17.4 18.0 # Utterances 148,642 4,874 153,516
Table 6: Development and test set statistics for veriï¬cation.
# 6.2. Baselines | 1706.08612#22 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 23 | Table 6: Development and test set statistics for veriï¬cation.
# 6.2. Baselines
GMM-UBM. The GMM-UBM system uses MFCCs of dimen- sion 13 as input. Cepstral mean and variance normalisation (CMVN) is applied on the features. Using the conventional GMM-UBM framework, a single speaker-independent univer- sal background model (UBM) of 1024 mixture components is trained for 10 iterations from the training data.
I-vectors/PLDA. Gender independent i-vector extractors [10] are trained on the VoxCeleb dataset to produce 400- dimensional i-vectors. Probabilistic LDA (PLDA) [41] is then used to reduce the dimension of the i-vectors to 200. Inference. For identiï¬cation, a one-vs-rest binary SVM clas- siï¬er is trained for each speaker m (m â 1...K). All feature inputs to the SVM are L2 normalised and a held out validation set is used to determine the C parameter (determines trade off between maximising the margin and penalising training errors). Classiï¬cation during test time is done by choosing the speaker corresponding to the highest SVM score. The PLDA scoring function [41] is used for veriï¬cation. | 1706.08612#23 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 24 | # 6.3. Results
Results are given in Tables 7 and 8. For both speaker recogni- tion tasks, the CNN provides superior performance to the tradi- tional state-of-the-art baselines.
For identiï¬cation we achieve an 80.5% top-1 classiï¬cation accuracy over 1,251 different classes, almost 20% higher than traditional state of the art baselines. The CNN architecture uses the average pooling layer for variable length test data. We also compare to two variants: âCNN-fc-3sâ, this architecture has a fully connected fc6 layer, and divides the test data into 3s seg- ments and averages the scores. As is evident there is a con- siderable drop in performance compared to the average pooling original â partly due to the increased number of parameters that must be learnt; âCNN-fc-3s no var. norm.â, this is the CNN-fc-3s architecture without the variance normalization pre-processing of the input (the input is still mean normalized). The differ- ence in performance between the two shows the importance of variance normalization for this data.
For veriï¬cation, the margin over the baselines is narrower, but still a signiï¬cant improvement, with the embedding being the crucial step. | 1706.08612#24 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 25 | For veriï¬cation, the margin over the baselines is narrower, but still a signiï¬cant improvement, with the embedding being the crucial step.
Accuracy I-vectors + SVM I-vectors + PLDA + SVM CNN-fc-3s no var. norm. CNN-fc-3s CNN Top-1 (%) 49.0 60.8 63.5 72.4 80.5 Top-5 (%) 56.6 75.6 80.3 87.4 92.1
Table 7: Results for identiï¬cation on VoxCeleb (higher is bet- ter). The different CNN architectures are described in Section 5.
Metrics GMM-UBM I-vectors + PLDA CNN-1024D CNN + Embedding Cmin det 0.80 0.73 0.75 0.71 EER (%) 15.0 8.8 10.2 7.8
Table 8: Results for veriï¬cation on VoxCeleb (lower is bet- ter).
# 7. Conclusions | 1706.08612#25 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 26 | Table 8: Results for veriï¬cation on VoxCeleb (lower is bet- ter).
# 7. Conclusions
We provide a fully automated and scalable pipeline for audio data collection and use it to create a large-scale speaker identiï¬cation dataset called VoxCeleb, with 1,251 speakers and over 100,000 utterances. In order to establish benchmark performance, we develop a novel CNN architecture with the ability to deal with variable length audio inputs, which out- performs traditional state-of-the-art methods for both speaker identiï¬cation and veriï¬cation on this dataset.
Acknowledgements. Funding for this research is provided by the EPSRC Programme Grant Seebibyte EP/M013774/1 and IARPA grant JANUS. We would like to thank Andrew Senior for helpful comments.
8. References [1] L. L. Stoll, âFinding difï¬cult speakers in automatic speaker recog- nition,â Technical Report No. UCB/EECS-2011-152, 2011.
[2] A. Krizhevsky, I. Sutskever, and G. E. Hinton, âImageNet classi- ï¬cation with deep convolutional neural networks,â in Advances in Neural Information Processing Systems, pp. 1106â1114, 2012. | 1706.08612#26 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 27 | [3] K. Simonyan and A. Zisserman, âVery deep convolutional net- works for large-scale image recognition,â in Proceedings of the International Conference on Learning Representations, 2015.
[4] K. He, X. Zhang, S. Ren, and J. Sun, âDeep residual learning for image recognition,â arXiv preprint arXiv:1512.03385, 2015.
[5] M. McLaren, L. Ferrer, D. Castan, and A. Lawson, âThe speak- ers in the wild (SITW) speaker recognition database,â INTER- SPEECH, vol. 2016, 2016.
[6] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, S. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. Berg, and F. Li, âImagenet large scale visual recognition challenge,â Inter- national Journal of Computer Vision, 2015. | 1706.08612#27 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 28 | [7] D. A. Reynolds, T. F. Quatieri, and R. B. Dunn, âSpeaker veri- ï¬cation using adapted gaussian mixture models,â Digital signal processing, vol. 10, no. 1-3, pp. 19â41, 2000.
[8] D. A. Reynolds and R. C. Rose, âRobust text-independent speaker identiï¬cation using gaussian mixture speaker models,â IEEE transactions on speech and audio processing, vol. 3, no. 1, pp. 72â 83, 1995.
[9] P. Kenny, âJoint factor analysis of speaker and session variability: Theory and algorithms,â CRIM, Montreal, CRIM-06/08-13, 2005.
[10] N. Dehak, P. J. Kenny, R. Dehak, P. Dumouchel, and P. Ouellet, âFront-end factor analysis for speaker veriï¬cation,â IEEE Trans- actions on Audio, Speech, and Language Processing, vol. 19, no. 4, pp. 788â798, 2011.
[11] U. H. Yapanel, X. Zhang, and J. H. Hansen, âHigh performance digit recognition in real car environments.,â in INTERSPEECH, 2002. | 1706.08612#28 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 29 | [12] J. H. Hansen, R. Sarikaya, U. H. Yapanel, and B. L. Pellom, âRo- bust speech recognition in noise: an evaluation using the spine corpus.,â in INTERSPEECH, pp. 905â908, 2001.
[13] T. N. Sainath, R. J. Weiss, A. W. Senior, K. W. Wilson, and O. Vinyals, âLearning the speech front-end with raw waveform CLDNNs,â in INTERSPEECH, pp. 1â5, 2015.
[14] S. Hershey, S. Chaudhuri, D. P. Ellis, J. F. Gemmeke, A. Jansen, R. C. Moore, M. Plakal, D. Platt, R. A. Saurous, B. Seybold, et al., âCNN architectures for large-scale audio classiï¬cation,â arXiv preprint arXiv:1609.09430, 2016. | 1706.08612#29 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 30 | [15] Y. Lukic, C. Vogt, O. D¨urr, and T. Stadelmann, âSpeaker iden- tiï¬cation and clustering using convolutional neural networks,â in IEEE 26th International Workshop on Machine Learning for Sig- nal Processing (MLSP), pp. 1â6, IEEE, 2016.
[16] D. van der Vloed, J. Bouten, and D. A. van Leeuwen, âNFI- FRITS: a forensic speaker recognition database and some ï¬rst ex- periments,â in The Speaker and Language Recognition Workshop, 2014.
[17] J. Hennebert, H. Melin, D. Petrovska, and D. Genoud, âPOLY- COST: a telephone-speech database for speaker recognition,â Speech communication, vol. 31, no. 2, pp. 265â270, 2000.
[18] J. B. Millar, J. P. Vonwiller, J. M. Harrington, and P. J. Der- mody, âThe Australian national database of spoken language,â in Proceedings of the IEEE International Conference on Acoustics, Speech and Signal Processing, vol. 1, pp. Iâ97, IEEE, 1994. | 1706.08612#30 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 31 | [19] J. S. Garofolo, L. F. Lamel, W. M. Fisher, J. G. Fiscus, and D. S. Pallett, âDARPA TIMIT acoustic-phonetic continous speech cor- pus CD-ROM. NIST speech disc 1-1.1,â NASA STI/Recon techni- cal report, vol. 93, 1993.
[20] C. McCool and S. Marcel, âMobio database for the ICPR 2010 face and speech competition,â tech. rep., IDIAP, 2009.
[21] R. Woo, A. Park, and T. J. Hazen, âThe MIT Mobile Device Speaker Veriï¬cation Corpus: Data collection and preliminary ex- periments,â The Speaker and Language Recognition Workshop, 2006.
[22] G. Morrison, C. Zhang, E. Enzinger, F. Ochoa, D. Bleach, M. Johnson, B. Folkes, S. De Souza, N. Cummins, and D. Chow, âForensic database of voice recordings of 500+ Australian English speakers,â URL: http://databases.forensic-voice-comparison.net, 2015. | 1706.08612#31 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 32 | [23] A. Janin, D. Baron, J. Edwards, D. Ellis, D. Gelbart, N. Morgan, B. Peskin, T. Pfau, E. Shriberg, A. Stolcke, et al., âThe ICSI meet- ing corpus,â in Proceedings of the IEEE International Conference on Acoustics, Speech and Signal Processing, vol. 1, IEEE, 2003.
[24] I. McCowan, J. Carletta, W. Kraaij, S. Ashby, S. Bourban, M. Flynn, M. Guillemot, T. Hain, J. Kadlec, V. Karaiskos, et al., âThe AMI meeting corpus,â in International Conference on Meth- ods and Techniques in Behavioral Research, vol. 88, 2005.
[25] P. Bell, M. J. Gales, T. Hain, J. Kilgour, P. Lanchantin, X. Liu, A. McParland, S. Renals, O. Saz, M. Wester, et al., âThe MGB challenge: Evaluating multi-genre broadcast media recognition,â in IEEE Workshop on Automatic Speech Recognition and Under- standing, pp. 687â693, IEEE, 2015. | 1706.08612#32 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 33 | [26] L. Feng and L. K. Hansen, âA new database for speaker recogni- tion,â tech. rep., 2005.
[27] J. J. Godfrey, E. C. Holliman, and J. McDaniel, âSwitchboard: Telephone speech corpus for research and development,â in Pro- ceedings of the IEEE International Conference on Acoustics, Speech and Signal Processing, vol. 1, pp. 517â520, IEEE, 1992.
[28] W. M. Fisher, G. R. Doddington, and K. M. Goudie-Marshall, âThe DARPA speech recognition research database: speciï¬ca- tions and status,â in Proc. DARPA Workshop on speech recogni- tion, pp. 93â99, 1986.
[29] C. S. Greenberg, âThe NIST year 2012 speaker recognition eval- uation plan,â NIST, Technical Report, 2012.
[30] O. M. Parkhi, A. Vedaldi, and A. Zisserman, âDeep face recog- nition,â in Proceedings of the British Machine Vision Conference, 2015. | 1706.08612#33 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 34 | [31] P. Chakravarty and T. Tuytelaars, âCross-modal supervision for learning active speaker detection in video,â arXiv preprint arXiv:1603.08907, 2016.
[32] D. E. King, âDlib-ml: A machine learning toolkit,â The Journal of Machine Learning Research, vol. 10, pp. 1755â1758, 2009.
[33] V. Kazemi and J. Sullivan, âOne millisecond face alignment with an ensemble of regression trees,â in Proceedings of the IEEE Con- ference on Computer Vision and Pattern Recognition, pp. 1867â 1874, 2014.
[34] J. S. Chung and A. Zisserman, âLip reading in the wild,â in Pro- ceedings of the Asian Conference on Computer Vision, 2016.
[35] M. Everingham, J. Sivic, and A. Zisserman, âTaking the bite out of automatic naming of characters in TV video,â Image and Vision Computing, vol. 27, no. 5, 2009.
[36] J. S. Chung and A. Zisserman, âOut of time: automated lip sync in the wild,â in Workshop on Multi-view Lip-reading, ACCV, 2016. | 1706.08612#34 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08612 | 35 | [37] K. Chatï¬eld, K. Simonyan, A. Vedaldi, and A. Zisserman, âRe- turn of the devil in the details: Delving deep into convolutional nets,â in Proceedings of the British Machine Vision Conference, 2014.
[38] S. Chopra, R. Hadsell, and Y. LeCun, âLearning a similarity met- ric discriminatively, with application to face veriï¬cation,â in Pro- ceedings of the IEEE Conference on Computer Vision and Pattern Recognition, vol. 1, pp. 539â546, IEEE, 2005.
[39] A. Vedaldi and K. Lenc, âMatconvnet â convolutional neural net- works for MATLAB,â CoRR, vol. abs/1412.4564, 2014.
[40] S. Ioffe and C. Szegedy, âBatch normalization: Accelerating deep network training by reducing internal covariate shift,â arXiv preprint arXiv:1502.03167, 2015.
[41] S. Ioffe, âProbabilistic linear discriminant analysis,â in Proceed- ings of the European Conference on Computer Vision, pp. 531â 542, Springer, 2006. | 1706.08612#35 | VoxCeleb: a large-scale speaker identification dataset | Most existing datasets for speaker identification contain samples obtained
under quite constrained conditions, and are usually hand-annotated, hence
limited in size. The goal of this paper is to generate a large scale
text-independent speaker identification dataset collected 'in the wild'. We
make two contributions. First, we propose a fully automated pipeline based on
computer vision techniques to create the dataset from open-source media. Our
pipeline involves obtaining videos from YouTube; performing active speaker
verification using a two-stream synchronization Convolutional Neural Network
(CNN), and confirming the identity of the speaker using CNN based facial
recognition. We use this pipeline to curate VoxCeleb which contains hundreds of
thousands of 'real world' utterances for over 1,000 celebrities. Our second
contribution is to apply and compare various state of the art speaker
identification techniques on our dataset to establish baseline performance. We
show that a CNN based architecture obtains the best performance for both
identification and verification. | http://arxiv.org/pdf/1706.08612 | Arsha Nagrani, Joon Son Chung, Andrew Zisserman | cs.SD | The dataset can be downloaded from
http://www.robots.ox.ac.uk/~vgg/data/voxceleb . 1706.08612v2: minor fixes; 6
pages | null | cs.SD | 20170626 | 20180530 | [
{
"id": "1502.03167"
},
{
"id": "1603.08907"
},
{
"id": "1609.09430"
},
{
"id": "1512.03385"
}
] |
1706.08098 | 1 | AbstractâRectiï¬ed linear unit (ReLU) is a widely used activa- tion function for deep convolutional neural networks. However, because of the zero-hard rectiï¬cation, ReLU networks miss the beneï¬ts from negative values. In this paper, we propose a novel activation function called ï¬exible rectiï¬ed linear unit (FReLU) to further explore the effects of negative values. By redesigning the rectiï¬ed point of ReLU as a learnable parameter, FReLU expands the states of the activation output. When the network is successfully trained, FReLU tends to converge to a negative value, which improves the expressiveness and thus the performance. Furthermore, FReLU is designed to be simple and effective without exponential functions to maintain low cost computation. For being able to easily used in various network architectures, FReLU does not rely on strict assumptions by self-adaption. We evaluate FReLU on three standard image classiï¬cation datasets, including CIFAR-10, CIFAR-100, and ImageNet. Experimental results show that the proposed method achieves fast convergence and higher performances on both plain and residual networks.
8 1 0 2
# n a J
9 2 ] V C . s c [
# I. INTRODUCTION | 1706.08098#1 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 2 | 8 1 0 2
# n a J
9 2 ] V C . s c [
# I. INTRODUCTION
Activation function is an important component in neural networks. It provides the non-linear properties for deep neural networks and controls the information propagation through adjacent layers. Therefore, the design of an activation function matters for the learning behaviors and performances of neural networks. And different activation functions have different characteristics and are used for different tasks. For example, long short-term memory (LSTM) models [1] use sigmoid or hyperbolic tangent functions, while rectiï¬ed linear unit (ReLU) [2], [3], [4] is more popular in convolutional neural networks (CNNs). In this paper, we mainly focus on extending ReLU function to improve convolutional neural networks.
2 v 8 9 0 8 0 . 6 0 7 1 : v i X r a | 1706.08098#2 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 3 | 2 v 8 9 0 8 0 . 6 0 7 1 : v i X r a
ReLU [5] is a classical activation function, which effec- tiveness has been veriï¬ed in previous works [6], [2], [3], [4]. The success of ReLU owes to identically propagating all the positive inputs, which alleviates gradient vanishing and allows the supervised training of much deeper neural networks. In addition, ReLU is computational efï¬cient by just outputing zero for negative inputs, and thus widely used in neural networks. Although ReLU is fantastic, researchers found that it is not the end of story about the activation function â the challenges of activation function arise from two main aspects: negative missing and zero-center property.
(a) ReLU (b) FReLU
relu(x)
fretu(x)
Illustration of (a) ReLU and (b) FReLU function.
[7], parametric ReLU (PReLU) [8], and randomized ReLU (RReLU) [9], enable non-zero slope to the negative part. It is proven that the negative parts are helpful for network learning. However, non-hard rectiï¬cation of these activation functions will destroy sparsity. | 1706.08098#3 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 4 | the authors explained that pushing the activation means closer to zero (zero-like) can speed up learning. ReLU is apparently non zero-like. LReLU, PReLU, and RReLU cannot ensure a noise-robust negative deactivation state. To this end, exponential linear unit (ELU) [10] was proposed to keep negative values and saturate the negative part to push the activation means closer to zero. Recent variants [11], [12], [13], [14], [15] of ELU and penal- ized tanh function [16] also demonstrate similar performance improvements. However, the incompatibility between ELU and batch normalization (BN) [17] has not been well treated.
In this paper, we propose a novel activation function called ï¬exible rectiï¬ed linear unit (FReLU), which can adaptively adjust the ReLU output by a rectiï¬ed point to capture nega- tive information and provide zero-like property. We evaluate FReLU on image classiï¬cation tasks and ï¬nd that the ï¬exible rectiï¬cation can improve the capacity of neural networks. In addition, the proposed activation function FReLU brings the following beneï¬ts: | 1706.08098#4 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 5 | Negative missing. ReLU simply restrains the negative value to hard-zero, which provides sparsity but results negative miss- ing. The variants of ReLU, including leaky ReLU (LReLU)
fast convergence and higher performance; ⢠low computation cost without exponential operation; ⢠compatibility with batch normalization; ⢠weak assumptions and self-adaptation.
II. THE PROPOSED METHOD
A. Flexible Rectiï¬ed Linear Unit
As illustrated in Fig. 1(a), let variable x represent the input, and rectiï¬ed linear unit (ReLU) [2] is deï¬ned as:
relu(x) = x 0 if x > 0 if x ⤠0 . (1)
By redesigning the rectiï¬ed point of ReLU as a learnable parameter, we propose ï¬exible rectiï¬ed linear unit (FReLU) to improve ï¬exibility on the horizontal and vertical axis, which is expressed as:
f relu(x) = relu(x + a) + b, (2)
where a and b are two learnable variables. By further consid- eration, activation function follows convolutional/linear layer generally, the variable a can be learned together with the bias of the preceding convolutional/linear layer. Therefore, the Equ. (2) equals to | 1706.08098#5 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 6 | f relu(x) = relu(x) + b, (3)
which is illustrated in Fig. 1(b).
Therefore, the forward pass function of FReLU is rewrite
# as:
f relu(x) = x + bl bl if x > 0 if x ⤠0 , (4)
where bl is the l-th layer-wise learnable parameter, which con- trols the output range of FReLU. Note that FReLU naturally generates ReLU when bl = 0.
The backward pass function of FReLU is given by:
1 0 = = 1 if x > 0 if x ⤠0 .
âf relu(x) âx âf relu(x) âbl B. Parameter Initialization with FReLU
As mentioned in [8], it is necessary to adopt appropriate initialization method for a novel activation function to prevent the vanishing problem of gradients. In this subsection, we provide a brief analysis on the initialization for FReLU. More discussions about the initialization of neural networks can refer to [18], [8]. | 1706.08098#6 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 7 | 1) Back propagation: For the back propagation case, the gradient of a convolution layer is computed by: Cost = , Where 2, = W/a,. WwW, is a c-by-? matrix which is reshaped from W). Here, c is the number of chan- nels for the input and 2? = k?d (k is the kernel size, and d is the number of channels for the output). We as- sume fj wis and w;, and 2Cost are independent of each other. When w; is initialized by a symmetric distribution around zero, Var [292] = = fyVarluiJE | (222)? |: And V7, ACost Wi x] for FReLU, we have: 2Cost = Creo Oost According to Equ. (5), we know that E [(2sest)?] = 1V ar[2Ceet]. Therefore, Var [2a] = 1A 57uVar [w)] Var [ acest]. Then
(5)
# [age]
for a network with L layers, we have Var [age] = Var <n aGext| (Tie > daVar (wl). Therefore, we have the initialization condition:
1 2 ËnlV ar [wl] = 1, âl,
which is the same with the msra method [8] for ReLU. | 1706.08098#7 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 8 | 1 2 ËnlV ar [wl] = 1, âl,
which is the same with the msra method [8] for ReLU.
2) Forward propagation: For the forward propagation case, that is 2; = W/)%,, where W; is a d-by-n ma- trix and n = kc. As above, we have Var[x] = nV ar|w;|E[z?7] with the independent assumption. For FReLU, 7 = max(0,x7_,) + max(0,2bz;_1) + b?. In general, x is finite or has Gaussian shape around zero, then Ez?) $Var(xi_-1] + 67. Thus, we have Var[x] ~ (4njVar[x;-1] + mbZ)Var[wi]. And for a network with L layers, Var[xz] © Vara] [jo dmVar[wi] + â¬, where ⬠= ar (Ha iran mVar(wi)). We found that the term ⬠makes forward propagation more complex. Fortunately when using Equ. (6) for initialization, Var[x,] ~ $Var[x1] + Vee 2 ae KDR.
# ck dL
# b2 k. | 1706.08098#8 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 9 | # ck dL
# b2 k.
k=2 In conclusion, when using the initialization condition (Equ. (6)) for FReLU, the variance of back propagation is stable and the variance of forward propagation will be scaled by some scalars. FReLU has a relatively stable learning characteristic except in complex applications. Thus, for stable learning, the absolute of bl prefers to be a small number, especially for very deep models. In practice, by using batch normalization [17], networks will be less sensitive to the initialization method. And the data-driven initialization method LSUV [19] is also a good choice. For convenience, in this paper, we use MSRA method [8] (Equ. (6)) for all our experiments.
C. Analysis and Discussion for FReLU
In this section, we analyze the improvement of FReLU for neural networks and discuss tips for FReLU.
1) State Extension by FReLU: By adding a learnable bias term, the output range of FReLU [b, +â) is helpful to ensure efï¬cient learning. When b < 0, FReLU satisï¬es the principle that activation functions with negative values can be used to reduce bias effect [10]. Besides, negative values can improve the expressiveness of the activation function. There are three output states represented by FReLU with b < 0: | 1706.08098#9 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 10 | f relu(x) = positive negative inactivation if x > 0 and x + b > 0 if x > 0 and x + b < 0 if x ⤠0 . (7)
Considering a layer with n units, FReLU with b = 0 (equal to ReLU) or b > 0 can only generate 2n output states, while FReLU with b < 0 can generate 3n output states. Shown in Table III, the learnable biases tend to negative b < 0 and bring the improvement in the network by training success. Another factor is that FReLU retains the same non-linear and sparse characteristics as ReLU. In addition, the self-adaptation of FReLU is also helpful to ï¬nd a specialized activation function.
(6) | 1706.08098#10 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 11 | (6)
2) Batch Normalization with FReLU: According to the conclusion in [10] and the experiments in Table II, PReLU, SReLU, and ELU are not compatible with batch normalization (BN) [17]. It is because training conï¬ict between the repre- sentation restore (scale γ and bias β) in BN and the negative parameter in the activation function. In FReLU, max (x, 0) isolates two pairs of learnable terms between BN and FReLU. In this paper, we introduce batch normalization (BN) [17] to stabilize the learning when using the large learning rate for achieving better performance. With BN, backward propagation through a layer is unaffected by the scale of its parameters. Speciï¬cally, for a scalar c, there is BN (W u) = BN ((cW )u) = âBN (W u) and thus âBN ((cW )u) . Batch normalization is âu also a data-driven method, does not rely on strict distribution assumptions. We show the compatibility between BN and FReLU in our experiments (Table II).
D. Comparisons
We compare the proposed FReLU function with a few cor- relative activation functions, including ReLU, PReLU, ELU, and SReLU. | 1706.08098#11 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 12 | Illustration of the correlative activation functions.
1) ReLU: The activation function ReLU [2] is deï¬ned as relu(x) = max(x, 0). The proposed FReLU function is an extension of ReLU by adding a learnable bias term b. There- fore, FReLU retains the same non-linear and sparse properties as ReLU, and extends the output range from [0, +â) to [b, +â). Here, b is learnable parameter for adaptive selection by training. When b = 0, FReLU generates ReLU. When b > 0, FReLU tends to move the output distribution of ReLU to larger positive areas, which is unnecessary for state extension proven in the experiments. When b < 0, FReLU expands the states of the output to increase the expressiveness of the activation function. | 1706.08098#12 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 13 | 2) PReLU/LReLU: The activation function PReLU [8] is deï¬nded as prelu(x) = max(x, 0) + k â min(x, 0), where k is the learnable parameter. When k is a small ï¬xed number, PReLU becomes LReLU [7]. To avoid zero gradients, PReLU and LReLU propagate the negative input with penalization, thus avoid negative missing. However, PReLU and LReLU probably lose sparsity, which is an important factor to achieve good performance for neural networks. Note that FReLU also can generate negative outputs, but in a different way. FReLU obstructs the negative input as same as ReLU, the backward
gradient of FReLU for the negative part is zero and retains sparsity. | 1706.08098#13 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 14 | gradient of FReLU for the negative part is zero and retains sparsity.
3) ELU: The activation function ELU [10] is deï¬ned as elu(x) = max(x, 0) + min((exp(x) â 1), 0). FReLU and ELU have similar shapes and properties in some extent. Different from ELU, FReLU uses the bias term instead of exponential operation, and reduces the computation complexity. Although FReLU is non-differentiable at x = 0, the experiments show that FReLU can achieve good performance. In addition, FReLU has a better compatibility with batch normalization than ELU. | 1706.08098#14 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 15 | 4) SReLU: In this paper, shifted ReLU (SReLU) is deï¬ned as srelu(x) = max(x, â), where â is the learnable param- eter. Both SReLU and FReLU have ï¬exibility of choosing horizontal shifts from learned biases and both SReLU and FReLU can choose vertical shifts. Speciï¬cally, SReLU can be reformed as srelu(x) = max(x, â) = max(x â â, 0) + â = max(xâ(αââ)ââ, 0)+â, where (αââ) is the learned bias for SReLU. To some extent, SReLU is equivalent to FReLU. In the experiments, we ï¬nd that SReLU is less compatible with batch normalization and lower performance than FReLU.
# III. EXPERIMENTS | 1706.08098#15 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 16 | # III. EXPERIMENTS
In this section, we evaluate FReLU on three standard image classiï¬cation datasets, including CIFAR-10, CIFAR-100 [20] and ImageNet [21]. We conduct all experiments based on fb.resnet.torch1 [22] using the default data augmentation and training settings. The default learning rate is initially set to 0.1. The weight decay is set to 0.0001, and the momentum is set to 0.9. For CIFAR-10 and CIFAR-100, the models are trained by stochastic gradient descent (SGD) with batch size of 128 for 200 epochs (no warming up). The learning rate is decreased by a factor of 10 at 81 and 122 epochs. For ImageNet, the models are trained by SGD with batch size of 256 for 90 epochs. The learning rate is decreased by a factor of 10 every 30 epochs. In addition, the parameter b for FReLU is set to â1 as the initialization by default in this paper. For fair comparison and reducing the random inï¬uences, all experimental results on CIFAR-10 and CIFAR-100 are reported with the mean and standard deviation of ï¬ve runs with different random seeds.
A. The Analyses for FReLU | 1706.08098#16 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 17 | A. The Analyses for FReLU
1) Convergence Rate and Performance: We ï¬rstly evaluate the proposed FReLU on a small convolutional neural network (referred to as SmallNet). It contains 3 convolutional layers followed by two fully connected layers detailed in Table I. The ACT module is either ReLU, ELU or FReLU. We used SmallNet to perform object classiï¬cation on the CIFAR-100 dataset [20]. Both training and test error rates are shown in Table II and we also draw learning curves in Fig. 3. We ï¬nd that FReLU achieves fast convergence and higher generation performance than ReLU, FReLU, ELU, and SReLU. Note that the error rate on test set is lower than training set is a normal phenomenon for a small network on CIFAR-100.
1https://github.com/facebook/fb.resnet.torch
Error rates 40 o 50 100 150 200 Epochs
100 150 200 Epochs °
=BNeReLU SBNSELU 80- âBN+FReLU o 50 100 150 200 Epochs
=BNeReLU SBNFELU âBN+FReLU B0- 70- 60 Error rates 50- 40 ° 50 100 150 200 Epochs | 1706.08098#17 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 18 | =BNeReLU SBNFELU âBN+FReLU B0- 70- 60 Error rates 50- 40 ° 50 100 150 200 Epochs
(a) Training error (b) Test error (c) Training error with BN (d) Test error with BN
Fig. 3. Error curves on the CIFAR-100 dataset for SmallNet. The base learning rate is 0.01. Best viewed in color.
TABLE I SMALLNET ARCHITECTURE ON THE CIFAR-100 DATASET. (BN: BATCH NORMALIZATION; ACT: ACTIVATION FUNCTION.)
Patch Size/Stride | #Kernels 3x3/1 32 Type Convolution (BN +) ACT MAX Pool Dropout (20%) Convolution (BN +) ACT MAX Pool Dropout (20%) Convolution (BN +) ACT = MAX Pool 2x2/2 = Dropout (20%) = Linear = (BN +) ACT = = Dropout (50%) = = Linear = Softmax = = 2x2/2 = 3x3/1 64 2x2/2 = 3x3/1
"100-300 5009 iso 200 250 300 350 Actuation ofthe Ist neuron
50 a 30 100 Bo 200 Activation ofthe Ist neuron
(a) ReLU (b) FReLU | 1706.08098#18 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 19 | 50 a 30 100 Bo 200 Activation ofthe Ist neuron
(a) ReLU (b) FReLU
Fig. 4. The distribution of deeply learned features for (a) ReLU and (b) FReLU on the test set of MNIST dataset. The points with different colors denote features from different classes. Best viewed in color.
expectation of activation function f (x) can be expressed as E{z] = J ye exp (â0.52?) f (a). When the parameter of FReLU b = â0.398 proven in Table|III| E[z] is approximately equal to zero. Therefore, FReLU is a normalize activation function to ensure the normalization of the entire network. | 1706.08098#19 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 20 | 2) Compatibility with Batch Normalization: We investigate the compatibilities with batch normalization (BN) on Small- Net. As same in [10], BN improves ReLU networks but damages ELU networks. We also empirically ï¬nd that BN does not improve PReLU, SReLU and FReLU when the base learning rate equals to 0.01. No matter with or without BN, FReLU all achieves the lowest testing error rates. Moreover, when using large base learning rate 0.1, ReLU, PReLU, ELU, SReLU, and FReLU networks all cannot converge without BN. With higher learning rates, ReLU, PReLU, and FReLU enjoy the beneï¬ts of BN, but ELU and SReLU does not. These phenomenons reï¬ect that FReLU is compatible with BN, which avoids exploding and achieves better performances with large learning rate. | 1706.08098#20 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 21 | In order to explore the advantage of FReLU, we further visualize the deep feature embeddings for ReLU and FReLU layers. We conduct this experiment on MNIST [23] dataset with LeNets++2. As the output number of the last hidden layer in LeNets++ is 2, we can directly plot the features on 2-D surface for visualization. In LeNets++, we use ReLU as the activation function. To visualize the effect of FReLU for feature learning, we only replace the activation function of the last hidden layer as FReLU. We draw the embeddings on the test dataset after training, which are shown in Fig. 4 and ten classes are shown in different colors. We observe that embeddings of the FReLU network are more discriminative than ReLUâs.The accuracy of the FReLU network is 97.8%, while the ReLU network is 97.05%. With negative bias, FReLU provides larger space for feature representation than ReLU. | 1706.08098#21 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 22 | 3) Different Initialization Values for FReLU: In this sub- section, we further explore the effects of different initialization values for FReLU. We report the results on the CIFAR-100 dataset with the SmallNet. By using a small network, the pa- rameter of FReLU can be fully learned. The test error rates and the convergence values b are shown in Table III. Interestingly, networks with different initialization values (including positive and negative values) for FReLU are ï¬nally converged to close negative value. Assuming the input x â¼ N (0, 1), the output
B. Results on CIFAR-10 and CIFAR-100
In this subsection, we compare ReLU, PReLU, ELU, SReLU and FReLU on the Network in Network (referred to as NIN) [24] model. We evaluate this model on both CIFAR-10 and CIFAR-100 datasets. We use the default base learning rate 0.1 and test with
2https://github.com/ydwen/caffe-face/tree/caffe-face/mnist example | 1706.08098#22 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 24 | Base Learning Rate Method ReLU PReLU ELU SReLU FReLU BN+ReLU BN+PReLU BN+ELU BN+SReLU BN+FReLU Training 44.20 (0.31) 42.49 (0.12) 40.79 (0.14) 39.85 (0.15) 38.69 (0.17) 44.07 (0.18) 42.46 (0.27) 45.10 (0.18) 43.47 (0.09) 40.38 (0.26) 0.01 Test 40.55 (0.25) 38.48 (0.33) 37.55 (0.47) 36.91 (0.17) 36.87 (0.35) 39.20 (0.32) 39.42 (0.54) 38.77 (0.18) 38.22 (0.28) 37.13 (0.30) Training not converge exploding exploding exploding exploding 42.60 (0.16) 40.85 (0.17) 43.27 (0.11) 40.15 (0.07) 38.83 (0.18) 0.1 Test not converge exploding exploding exploding exploding 38.50 (0.43) 37.14 (0.42) 37.80 (0.16) | 1706.08098#24 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 26 | TABLE III MEAN (STD) ERROR RESULTS ON THE CIFAR-100 DATASET AND CONVERGENCE VALUES (LAYER 1 TO 4) FOR FRELU WITH SMALLNET.
Init. Value 0.5 0.2 0 -0.4 -1 Error Rate 37.05 (0.07) 36.71 (0.32) 36.91 (0.34) 37.10 (0.33) 36.87 (0.35) Layer1 -0.3175 -0.3112 -0.3144 -0.3235 -0.3272 Layer2 -0.4570 -0.4574 -0.4367 -0.4480 -0.4757 Layer3 -0.2824 -0.2749 -0.2891 -0.2917 -0.2849 Layer4 -0.3284 -0.3314 -0.3313 -0.3315 -0.3282
TABLE IV COMPARING RELU [5], PRELU [8], ELU [10], SRELU AND FRELU WITH NIN [24] MODEL ON THE CIFAR-10 AND CIFAR-100 DATASETS. THE BASE LEARNING RATE IS 0.1. WE REPORT THE MEAN (STD) RESULTS OVER FIVE RUNS. | 1706.08098#26 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 27 | Dataset Method BN+ReLU BN+PReLU BN+ELU BN+SReLU BN+FReLU CIFAR-10 Training 2.89(0.11) 1.36(0.03) 4.15(0.07) 2.68(0.06) 2.02(0.06) Test 8.05(0.15) 8.86(0.18) 8.08(0.26) 7.93(0.24) 7.30(0.20) CIFAR-100 Training 14.11(0.06) 8.96(0.12) 13.36(0.10) 13.48(0.12) 11.40(0.11) Test 29.46(0.29) 33.73(0.29) 28.33(0.32) 29.50(0.34) 28.47(0.21)
BN. Results are shown in Table IV. PReLU seems overï¬tting and does not obtain good performance. The proposed method FReLU achieves the lowest error rates on the test datasets.
(input) 7 {conv 3x3} BN t (convae ) â BN â- CT } | 1706.08098#27 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 28 | (input) 7 {conv 3x3} BN t (convae ) â BN â- CT }
(Input _} 7 (Conv 3x3} BN â t as (cova ) â BN +e {Output}
[input _ } } (Conv 3x3} P + ay (conv 3x3} â= BN ++ il {Output}
(input) (Input _} [input _ } 7 7 } {conv 3x3} (Conv 3x3} (Conv 3x3} BN BN t â t P + as ay (convae ) (cova ) (conv 3x3} â â â= BN BN BN â- +e ++ CT } il {Output} {Output}
(a) Ori. bottleneck [4] (b) w/o ACT after ad- dition (c) w/o BN after ï¬rst Conv [25]
Fig. 5. Various residual blocks.
C. Results on ImageNet
We also evaluate FReLU on the ImageNet dataset. Table VI shows the results with NIN model and a modiï¬ed CaffeNet, where the result of CaffeNet comes from a benchmark testing [26] and the detailed settings can refer to their project web- site3. FReLU performs well, outperforming other activation functions. | 1706.08098#28 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 29 | # IV. CONCLUSION AND FUTURE WORK
2) Evaluation on Residual Networks: We also investigate the effectiveness of FReLU with residual networks on the CIFAR-10 and CIFAR-100 datasets. Results are shown in Table V. In order to compare the compatibility of FReLU and ELU with BN, we ï¬rst investigate the performances of residual networks with simply replacing the ReLU with FReLU and ELU, that is using the architecture in Fig. 5(a). We observe that ELU damages the performances but FReLU improves, which demonstrates that FReLU has the higher compatibility with BN than ELU. Inspired by [25], we further compare the performances with the modiï¬ed networks, where ELU uses the architecture in Fig. 5(c) and FReLU uses the architecture in Fig. 5(b). We also observe that FReLU achieves better performances. | 1706.08098#29 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 30 | In this paper, a novel activation function called FReLU is proposed to improve convolutional neural networks. As a variant of ReLU, FReLU retains non-linear and sparsity as ReLU and extends the expressiveness. FReLU is a general concept and does not depend on any speciï¬c assumption. We show that FReLU achieves higher performances and empirically ï¬nd that FReLU is more compatible with batch normalization than ELU. Our results suggest that negative values are useful for neural networks. There are still many questions requiring further investigation: (1) How to solve the dead neuron problem well? (2) How to design an efï¬cient
3
3 https://github.com/ducha-aiki/caffenet-benchmark/blob/master/ Activations.md
TABLE V COMPARING RELU, ELU ((A) [10] (C) [25]) AND FRELU WITH RESNET-20/32/44/56/110 [4] ON THE CIFAR-10 AND CIFAR-100 DATASETS. WE REPORT THE MEAN (STD) ERROR RATES OVER FIVE RUNS. | 1706.08098#30 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 31 | Dataset #Depths Original ELU (a) FReLU (a) ELU (c) FReLU (b) Dataset #Depths Original ELU (c) FReLU (b) 20 8.12(0.18) 8.04(0.08) 8.10(0.18) 8.28(0.09) 8.00(0.14) 20 31.93(0.13) 31.90(0.36) 31.84(0.30) 32 7.28(0.19) 7.62(0.21) 7.30(0.17) 7.07(0.17) 6.99(0.11) 32 30.16(0.32) 30.39(0.37) 29.95(0.27) CIFAR-10 44 6.97(0.24) 7.51(0.22) 6.91(0.25) 6.78(0.10) 6.58(0.19) CIFAR-100 44 29.30(0.45) 29.34(0.39) 29.02(0.25) 56 6.87(0.54) 7.71(0.26) 6.54(0.22) 6.54(0.20) 6.31(0.20) 56 | 1706.08098#31 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
1706.08098 | 33 | TABLE VI COMPARING RELU, ELU AND FRELU WITH NIN MODEL ON THE IMAGENET DATASET.
[12] Y. Li, C. Fan, Y. Li, and Q. Wu, âImproving deep neural net- work with multiple parametric exponential linear units,â arXiv preprint arXiv:1606.00305, 2016.
Network NIN CaffeNet3 Method BN+ReLU BN+ELU BN+FReLU ReLU PReLU ELU FReLU Top-1 error 35.65 38.55 34.82 53.00 52.20 51.20 51.20 Top-5 error 14.53 16.62 14.00 â â â â
[13] B. Carlile, G. Delamarter, P. Kinney, A. Marti, and B. Whitney, âIm- proving deep learning by inverse square root linear units (isrlus),â arXiv preprint arXiv:1710.09967, 2017. | 1706.08098#33 | FReLU: Flexible Rectified Linear Units for Improving Convolutional Neural Networks | Rectified linear unit (ReLU) is a widely used activation function for deep
convolutional neural networks. However, because of the zero-hard rectification,
ReLU networks miss the benefits from negative values. In this paper, we propose
a novel activation function called \emph{flexible rectified linear unit
(FReLU)} to further explore the effects of negative values. By redesigning the
rectified point of ReLU as a learnable parameter, FReLU expands the states of
the activation output. When the network is successfully trained, FReLU tends to
converge to a negative value, which improves the expressiveness and thus the
performance. Furthermore, FReLU is designed to be simple and effective without
exponential functions to maintain low cost computation. For being able to
easily used in various network architectures, FReLU does not rely on strict
assumptions by self-adaption. We evaluate FReLU on three standard image
classification datasets, including CIFAR-10, CIFAR-100, and ImageNet.
Experimental results show that the proposed method achieves fast convergence
and higher performances on both plain and residual networks. | http://arxiv.org/pdf/1706.08098 | Suo Qiu, Xiangmin Xu, Bolun Cai | cs.CV | null | null | cs.CV | 20170625 | 20180129 | [
{
"id": "1505.00853"
},
{
"id": "1502.03167"
},
{
"id": "1602.07261"
},
{
"id": "1511.07289"
},
{
"id": "1605.09332"
},
{
"id": "1706.02515"
},
{
"id": "1602.05980"
},
{
"id": "1710.09967"
},
{
"id": "1511.06422"
},
{
"id": "1606.00305"
},
{
"id": "1604.04112"
}
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.