File size: 3,509 Bytes
69f18b6 99c6279 0ad3c7b |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 |
---
license: mit
language:
- en
metrics:
- accuracy
pipeline_tag: audio-to-audio
tags:
- watermark
---
# WavMark
> AI-based Audio Watermarking Tool
- âš¡ **Leading Stability:** The watermark resist to **10** types of common attacks like Gaussian noise, MP3 compression, low-pass filter, and speed variation; achieving over **29** times in robustness compared with the traditional method.
- 🙉 **High Imperceptibility:** The watermarked audio has over 38dB SNR and 4.3 PESQ, which means it is inaudible to humans. Listen the examples: [https://wavmark.github.io/](https://wavmark.github.io/).
- 😉 **Easy for Extending:** This project is entirely python based. You can easily leverage our underlying PyTorch model to implement a custom watermarking system with higher capacity or robustness.
- 🤗 **Huggingface Spaces:** Try our online demonstration: https://huggingface.co/spaces/M4869/WavMark
## Installation
```
pip install wavmark
```
## Basic Usage
The following code adds 16-bit watermark into the input file `example.wav` and subsequently performs decoding:
```python
import numpy as np
import soundfile
import torch
import wavmark
# 1.load model
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = wavmark.load_model().to(device)
# 2.create 16-bit payload
payload = np.random.choice([0, 1], size=16)
print("Payload:", payload)
# 3.read host audio
# the audio should be a single-channel 16kHz wav, you can read it using soundfile:
signal, sample_rate = soundfile.read("example.wav")
# Otherwise, you can use the following function to convert the host audio to single-channel 16kHz format:
# from wavmark.utils import file_reader
# signal = file_reader.read_as_single_channel("example.wav", aim_sr=16000)
# 4.encode watermark
watermarked_signal, _ = wavmark.encode_watermark(model, signal, payload, show_progress=True)
# you can save it as a new wav:
# soundfile.write("output.wav", watermarked_signal, 16000)
# 5.decode watermark
payload_decoded, _ = wavmark.decode_watermark(model, watermarked_signal, show_progress=True)
BER = (payload != payload_decoded).mean() * 100
print("Decode BER:%.1f" % BER)
```
## Low-level Access
```python
# 1.load model
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = wavmark.load_model().to(device)
# 2. take 16,000 samples
signal, sample_rate = soundfile.read("example.wav")
trunck = signal[0:16000]
message_npy = np.random.choice([0, 1], size=32)
# 3. do encode:
with torch.no_grad():
signal = torch.FloatTensor(trunck).to(device)[None]
message_tensor = torch.FloatTensor(message_npy).to(device)[None]
signal_wmd_tensor = model.encode(signal, message_tensor)
signal_wmd_npy = signal_wmd_tensor.detach().cpu().numpy().squeeze()
# 4.do decode:
with torch.no_grad():
signal = torch.FloatTensor(signal_wmd_npy).to(device).unsqueeze(0)
message_decoded_npy = (model.decode(signal) >= 0.5).int().detach().cpu().numpy().squeeze()
BER = (message_npy != message_decoded_npy).mean() * 100
print("BER:", BER)
```
## Thanks
The "[Audiowmark](https://uplex.de/audiowmark)" developed by Stefan Westerfeld has provided valuable ideas for the design of this project.
## Citation
```
@misc{chen2023wavmark,
title={WavMark: Watermarking for Audio Generation},
author={Guangyu Chen and Yu Wu and Shujie Liu and Tao Liu and Xiaoyong Du and Furu Wei},
year={2023},
eprint={2308.12770},
archivePrefix={arXiv},
primaryClass={cs.SD}
}
```
|