Generating audio signals with custom parameters
by Alberto Boschetti, Luca Massaron, Bastiaan Sjardin, John Hearty, Prateek Joshi
Python: Real World Machine Learning
- Python: Real World Machine Learning
- Table of Contents
- Python: Real World Machine Learning
- Python: Real World Machine Learning
- Credits
- Preface
- I. Module 1
- 1. The Realm of Supervised Learning
- Introduction
- Preprocessing data using different techniques
- Label encoding
- Building a linear regressor
- Computing regression accuracy
- Achieving model persistence
- Building a ridge regressor
- Building a polynomial regressor
- Estimating housing prices
- Computing the relative importance of features
- Estimating bicycle demand distribution
- 2. Constructing a Classifier
- Introduction
- Building a simple classifier
- Building a logistic regression classifier
- Building a Naive Bayes classifier
- Splitting the dataset for training and testing
- Evaluating the accuracy using cross-validation
- Visualizing the confusion matrix
- Extracting the performance report
- Evaluating cars based on their characteristics
- Extracting validation curves
- Extracting learning curves
- Estimating the income bracket
- 3. Predictive Modeling
- 4. Clustering with Unsupervised Learning
- Introduction
- Clustering data using the k-means algorithm
- Compressing an image using vector quantization
- Building a Mean Shift clustering model
- Grouping data using agglomerative clustering
- Evaluating the performance of clustering algorithms
- Automatically estimating the number of clusters using DBSCAN algorithm
- Finding patterns in stock market data
- Building a customer segmentation model
- 5. Building Recommendation Engines
- Introduction
- Building function compositions for data processing
- Building machine learning pipelines
- Finding the nearest neighbors
- Constructing a k-nearest neighbors classifier
- Constructing a k-nearest neighbors regressor
- Computing the Euclidean distance score
- Computing the Pearson correlation score
- Finding similar users in the dataset
- Generating movie recommendations
- 6. Analyzing Text Data
- Introduction
- Preprocessing data using tokenization
- Stemming text data
- Converting text to its base form using lemmatization
- Dividing text using chunking
- Building a bag-of-words model
- Building a text classifier
- Identifying the gender
- Analyzing the sentiment of a sentence
- Identifying patterns in text using topic modeling
- 7. Speech Recognition
- 8. Dissecting Time Series and Sequential Data
- Introduction
- Transforming data into the time series format
- Slicing time series data
- Operating on time series data
- Extracting statistics from time series data
- Building Hidden Markov Models for sequential data
- Building Conditional Random Fields for sequential text data
- Analyzing stock market data using Hidden Markov Models
- 9. Image Content Analysis
- Introduction
- Operating on images using OpenCV-Python
- Detecting edges
- Histogram equalization
- Detecting corners
- Detecting SIFT feature points
- Building a Star feature detector
- Creating features using visual codebook and vector quantization
- Training an image classifier using Extremely Random Forests
- Building an object recognizer
- 10. Biometric Face Recognition
- Introduction
- Capturing and processing video from a webcam
- Building a face detector using Haar cascades
- Building eye and nose detectors
- Performing Principal Components Analysis
- Performing Kernel Principal Components Analysis
- Performing blind source separation
- Building a face recognizer using Local Binary Patterns Histogram
- 11. Deep Neural Networks
- Introduction
- Building a perceptron
- Building a single layer neural network
- Building a deep neural network
- Creating a vector quantizer
- Building a recurrent neural network for sequential data analysis
- Visualizing the characters in an optical character recognition database
- Building an optical character recognizer using neural networks
- 12. Visualizing Data
- 1. The Realm of Supervised Learning
- II. Module 2
- 1. Unsupervised Machine Learning
- 2. Deep Belief Networks
- 3. Stacked Denoising Autoencoders
- 4. Convolutional Neural Networks
- 5. Semi-Supervised Learning
- 6. Text Feature Engineering
- 7. Feature Engineering Part II
- 8. Ensemble Methods
- 9. Additional Python Machine Learning Tools
- A. Chapter Code Requirements
- III. Module 3
- 1. First Steps to Scalability
- 2. Scalable Learning in Scikit-learn
- 3. Fast SVM Implementations
- 4. Neural Networks and Deep Learning
- The neural network architecture
- Neural networks and regularization
- Neural networks and hyperparameter optimization
- Neural networks and decision boundaries
- Deep learning at scale with H2O
- Deep learning and unsupervised pretraining
- Deep learning with theanets
- Autoencoders and unsupervised learning
- Summary
- 5. Deep Learning with TensorFlow
- 6. Classification and Regression Trees at Scale
- 7. Unsupervised Learning at Scale
- 8. Distributed Environments – Hadoop and Spark
- 9. Practical Machine Learning with Spark
- A. Introduction to GPUs and Theano
- A. Bibliography
- Index
We can use NumPy to generate audio signals. As we discussed earlier, audio signals are complex mixtures of sinusoids. So, we will keep this in mind when we generate our own audio signal.
- Create a new Python file, and import the following packages:
import numpy as np import matplotlib.pyplot as plt from scipy.io.wavfile import write
- We need to define the output file where the generated audio will be stored:
# File where the output will be saved output_file = 'output_generated.wav'
- Let's specify the audio generation parameters. We want to generate a three-second long signal with a sampling frequency of
44100and a tonal frequency of587Hz. The values on the time axis will go from -2*pi to 2*pi:# Specify audio parameters duration = 3 # seconds sampling_freq = 44100 # Hz tone_freq = 587 min_val = -2 * np.pi max_val = 2 * np.pi
- Let's generate the time axis and the audio signal. The audio signal is a simple sinusoid with the previously mentioned parameters:
# Generate audio t = np.linspace(min_val, max_val, duration * sampling_freq) audio = np.sin(2 * np.pi * tone_freq * t)
- Let's add some noise to the signal:
# Add some noise noise = 0.4 * np.random.rand(duration * sampling_freq) audio += noise
- We need to scale the values to 16-bit integers before we store them:
# Scale it to 16-bit integer values scaling_factor = pow(2,15) - 1 audio_normalized = audio / np.max(np.abs(audio)) audio_scaled = np.int16(audio_normalized * scaling_factor)
- Write this signal to the output file:
# Write to output file write(output_file, sampling_freq, audio_scaled)
- Plot the signal using the first 100 values:
# Extract first 100 values for plotting audio = audio[:100]
- Generate the time axis:
# Build the time axis x_values = np.arange(0, len(audio), 1) / float(sampling_freq)
- Convert the time axis into seconds:
# Convert to seconds x_values *= 1000
- Plot the signal, as follows:
# Plotting the chopped audio signal plt.plot(x_values, audio, color='black') plt.xlabel('Time (ms)') plt.ylabel('Amplitude') plt.title('Audio signal') plt.show() - The full code is in the
generate.pyfile. If you run this code, you will get the following figure:
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.