亲耳“听见”神经网络的声音：梯度变化一听即可辨别(附代码)

  1import pyaudio
  2import numpy as np
  3import wave
  4
  5import torch
  6import torch.nn as nn
  7import torch.nn.functional as F
  8import torch.optim as optim
  9from torchvision import datasets, transforms
 10
 11
 12class Net(nn.Module):
 13    def __init__(self):
 14        super(Net, self).__init__()
 15        self.conv1 = nn.Conv2d(1, 20, 5, 1)
 16        self.conv2 = nn.Conv2d(20, 50, 5, 1)
 17        self.fc1 = nn.Linear(4*4*50, 500)
 18        self.fc2 = nn.Linear(500, 10)
 19
 20        self.ordered_layers = [self.conv1,
 21                               self.conv2,
 22                               self.fc1,
 23                               self.fc2]
 24
 25    def forward(self, x):
 26        x = F.relu(self.conv1(x))
 27        x = F.max_pool2d(x, 2, 2)
 28        x = F.relu(self.conv2(x))
 29        x = F.max_pool2d(x, 2, 2)
 30        x = x.view(-1, 4*4*50)
 31        x = F.relu(self.fc1(x))
 32        x = self.fc2(x)
 33        return F.log_softmax(x, dim=1)
 34
 35
 36def open_stream(fs):
 37    p = pyaudio.PyAudio()
 38    stream = p.open(format=pyaudio.paFloat32,
 39                    channels=1,
 40                    rate=fs,
 41                    output=True)
 42    return p, stream
 43
 44
 45def generate_tone(fs, freq, duration):
 46    npsin = np.sin(2 * np.pi * np.arange(fs*duration) * freq / fs)
 47    samples = npsin.astype(np.float32)
 48    return 0.1 * samples
 49
 50
 51def train(model, device, train_loader, optimizer, epoch):
 52    model.train()
 53
 54    fs = 44100
 55    duration = 0.01
 56    f = 200.0
 57    p, stream = open_stream(fs)
 58
 59    frames = []
 60
 61    for batch_idx, (data, target) in enumerate(train_loader):
 62        data, target = data.to(device), target.to(device)
 63        optimizer.zero_grad()
 64        output = model(data)
 65        loss = F.nll_loss(output, target)
 66        loss.backward()
 67
 68        norms = []
 69        for layer in model.ordered_layers:
 70            norm_grad = layer.weight.grad.norm()
 71            norms.append(norm_grad)
 72
 73            tone = f + ((norm_grad.numpy()) * 100.0)
 74            tone = tone.astype(np.float32)
 75            samples = generate_tone(fs, tone, duration)
 76
 77            frames.append(samples)
 78
 79        silence = np.zeros(samples.shape[0] * 2,
 80                           dtype=np.float32)
 81        frames.append(silence)
 82
 83        optimizer.step()
 84
 85        # Just 200 steps per epoach
 86        if batch_idx == 200:
 87            break
 88
 89    wf = wave.open("sgd_lr_1_0_bs256.wav", 'wb')
 90    wf.setnchannels(1)
 91    wf.setsampwidth(p.get_sample_size(pyaudio.paFloat32))
 92    wf.setframerate(fs)
 93    wf.writeframes(b''.join(frames))
 94    wf.close()
 95
 96    stream.stop_stream()
 97    stream.close()
 98    p.terminate()
 99
100
101def run_main():
102    device = torch.device("cpu")
103
104    train_loader = torch.utils.data.DataLoader(
105        datasets.MNIST('../data', train=True, download=True,
106                       transform=transforms.Compose([
107                           transforms.ToTensor(),
108                           transforms.Normalize((0.1307,), (0.3081,))
109                       ])),
110        batch_size=256, shuffle=True)
111
112    model = Net().to(device)
113    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
114
115    for epoch in range(1, 2):
116        train(model, device, train_loader, optimizer, epoch)
117
118
119if __name__ == "__main__":
120    run_main()