Unnamed: 0
int64 0
16k
| text_prompt
stringlengths 110
62.1k
| code_prompt
stringlengths 37
152k
|
|---|---|---|
3,400 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Tutorial 4 (Simulator)
This is a tutorial for E-Cell4. Here, we explain how to handle Simulators.
Each World has its corresponding Simulator.
Step1: Simulator needs a Model and World at the instantiation.
Step2: A Simulator has getters for a simulation time, a step interval, and the next-event time. In principle, a Simulator returns the World's time as its simulation time, and does a sum of the current time and a step interval as the next-event time.
Step3: A Simulator can return the connected model and world. They are not copies, but the shared objects.
Step4: If you change a World after connecting it to a Simulator, you have to call initialize() manually before step(). The call will update the internal state of the Simulator.
Step5: Simulator has two types of step functions. First, with no argument, step() increments the time until next_time().
Step6: With an argument upto, if upto is later than next_time(), step(upto) increments the time upto the next_time() and returns True. Otherwise, it increments the time for upto and returns False. (If the current time t() is less than upto, it does nothing and returns False.)
Step7: For a discrete-step simulation, the main loop should be written like | Python Code:
from ecell4.core import *
from ecell4.gillespie import GillespieWorld as world_type, GillespieSimulator as simulator_type
# from ecell4.ode import ODEWorld as world_type, ODESimulator as simulator_type
# from ecell4.lattice import LatticeWorld as world_type, LatticeSimulator as simulator_type
# from ecell4.meso import MesoscopicWorld as world_type, MesoscopicSimulator as simulator_type
# from ecell4.bd import BDWorld as world_type, BDSimulator as simulator_type
# from ecell4.egfrd import EGFRDWorld as world_type, EGFRDSimulator as simulator_type
Explanation: Tutorial 4 (Simulator)
This is a tutorial for E-Cell4. Here, we explain how to handle Simulators.
Each World has its corresponding Simulator.
End of explanation
m = NetworkModel()
m.add_species_attribute(Species("A", "0.0025", "1"))
m.add_reaction_rule(create_degradation_reaction_rule(Species("A"), 0.693 / 1))
w = world_type(Real3(1, 1, 1))
w.bind_to(m)
w.add_molecules(Species("A"), 60)
sim = simulator_type(m, w)
sim.set_dt(0.01) #XXX: Optional
Explanation: Simulator needs a Model and World at the instantiation.
End of explanation
print(sim.num_steps())
print(sim.t(), w.t())
print(sim.next_time(), sim.t() + sim.dt())
Explanation: A Simulator has getters for a simulation time, a step interval, and the next-event time. In principle, a Simulator returns the World's time as its simulation time, and does a sum of the current time and a step interval as the next-event time.
End of explanation
print(sim.model(), sim.world())
Explanation: A Simulator can return the connected model and world. They are not copies, but the shared objects.
End of explanation
sim.world().add_molecules(Species("A"), 60) # w.add_molecules(Species("A"), 60)
sim.initialize()
# w.save('test.h5')
Explanation: If you change a World after connecting it to a Simulator, you have to call initialize() manually before step(). The call will update the internal state of the Simulator.
End of explanation
print("%.3e %.3e" % (sim.t(), sim.next_time()))
sim.step()
print("%.3e %.3e" % (sim.t(), sim.next_time()))
Explanation: Simulator has two types of step functions. First, with no argument, step() increments the time until next_time().
End of explanation
print("%.3e %.3e" % (sim.t(), sim.next_time()))
print(sim.step(0.1))
print("%.3e %.3e" % (sim.t(), sim.next_time()))
Explanation: With an argument upto, if upto is later than next_time(), step(upto) increments the time upto the next_time() and returns True. Otherwise, it increments the time for upto and returns False. (If the current time t() is less than upto, it does nothing and returns False.)
End of explanation
# w.load('test.h5')
sim.initialize()
next_time, dt = 0.0, 1e-2
for _ in range(5):
while sim.step(next_time): pass
next_time += dt
print("%.3e %.3e %d %g" % (sim.t(), sim.dt(), sim.num_steps(), w.num_molecules(Species("A"))))
Explanation: For a discrete-step simulation, the main loop should be written like:
End of explanation |
3,401 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Anna KaRNNa
In this notebook, we'll build a character-wise RNN trained on Anna Karenina, one of my all-time favorite books. It'll be able to generate new text based on the text from the book.
This network is based off of Andrej Karpathy's post on RNNs and implementation in Torch. Also, some information here at r2rt and from Sherjil Ozair on GitHub. Below is the general architecture of the character-wise RNN.
<img src="assets/charseq.jpeg" width="500">
Step1: First we'll load the text file and convert it into integers for our network to use. Here I'm creating a couple dictionaries to convert the characters to and from integers. Encoding the characters as integers makes it easier to use as input in the network.
Step2: Let's check out the first 100 characters, make sure everything is peachy. According to the American Book Review, this is the 6th best first line of a book ever.
Step3: And we can see the characters encoded as integers.
Step4: Since the network is working with individual characters, it's similar to a classification problem in which we are trying to predict the next character from the previous text. Here's how many 'classes' our network has to pick from.
Step5: Making training mini-batches
Here is where we'll make our mini-batches for training. Remember that we want our batches to be multiple sequences of some desired number of sequence steps. Considering a simple example, our batches would look like this
Step6: Now I'll make my data sets and we can check out what's going on here. Here I'm going to use a batch size of 10 and 50 sequence steps.
Step7: If you implemented get_batches correctly, the above output should look something like
```
x
[[55 63 69 22 6 76 45 5 16 35]
[ 5 69 1 5 12 52 6 5 56 52]
[48 29 12 61 35 35 8 64 76 78]
[12 5 24 39 45 29 12 56 5 63]
[ 5 29 6 5 29 78 28 5 78 29]
[ 5 13 6 5 36 69 78 35 52 12]
[63 76 12 5 18 52 1 76 5 58]
[34 5 73 39 6 5 12 52 36 5]
[ 6 5 29 78 12 79 6 61 5 59]
[ 5 78 69 29 24 5 6 52 5 63]]
y
[[63 69 22 6 76 45 5 16 35 35]
[69 1 5 12 52 6 5 56 52 29]
[29 12 61 35 35 8 64 76 78 28]
[ 5 24 39 45 29 12 56 5 63 29]
[29 6 5 29 78 28 5 78 29 45]
[13 6 5 36 69 78 35 52 12 43]
[76 12 5 18 52 1 76 5 58 52]
[ 5 73 39 6 5 12 52 36 5 78]
[ 5 29 78 12 79 6 61 5 59 63]
[78 69 29 24 5 6 52 5 63 76]]
``
although the exact numbers will be different. Check to make sure the data is shifted over one step fory`.
Building the model
Below is where you'll build the network. We'll break it up into parts so it's easier to reason about each bit. Then we can connect them up into the whole network.
<img src="assets/charRNN.png" width=500px>
Inputs
First off we'll create our input placeholders. As usual we need placeholders for the training data and the targets. We'll also create a placeholder for dropout layers called keep_prob. This will be a scalar, that is a 0-D tensor. To make a scalar, you create a placeholder without giving it a size.
Exercise
Step8: LSTM Cell
Here we will create the LSTM cell we'll use in the hidden layer. We'll use this cell as a building block for the RNN. So we aren't actually defining the RNN here, just the type of cell we'll use in the hidden layer.
We first create a basic LSTM cell with
python
lstm = tf.contrib.rnn.BasicLSTMCell(num_units)
where num_units is the number of units in the hidden layers in the cell. Then we can add dropout by wrapping it with
python
tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=keep_prob)
You pass in a cell and it will automatically add dropout to the inputs or outputs. Finally, we can stack up the LSTM cells into layers with tf.contrib.rnn.MultiRNNCell. With this, you pass in a list of cells and it will send the output of one cell into the next cell. For example,
python
tf.contrib.rnn.MultiRNNCell([cell]*num_layers)
This might look a little weird if you know Python well because this will create a list of the same cell object. However, TensorFlow will create different weight matrices for all cell objects. Even though this is actually multiple LSTM cells stacked on each other, you can treat the multiple layers as one cell.
We also need to create an initial cell state of all zeros. This can be done like so
python
initial_state = cell.zero_state(batch_size, tf.float32)
Exercise
Step9: RNN Output
Here we'll create the output layer. We need to connect the output of the RNN cells to a full connected layer with a softmax output. The softmax output gives us a probability distribution we can use to predict the next character, so we want this layer to have size $C$, the number of classes/characters we have in our text.
If our input has batch size $N$, number of steps $M$, and the hidden layer has $L$ hidden units, then the output is a 3D tensor with size $N \times M \times L$. The output of each LSTM cell has size $L$, we have $M$ of them, one for each sequence step, and we have $N$ sequences. So the total size is $N \times M \times L$.
We are using the same fully connected layer, the same weights, for each of the outputs. Then, to make things easier, we should reshape the outputs into a 2D tensor with shape $(M * N) \times L$. That is, one row for each sequence and step, where the values of each row are the output from the LSTM cells. We get the LSTM output as a list, lstm_output. First we need to concatenate this whole list into one array with tf.concat. Then, reshape it (with tf.reshape) to size $(M * N) \times L$.
One we have the outputs reshaped, we can do the matrix multiplication with the weights. We need to wrap the weight and bias variables in a variable scope with tf.variable_scope(scope_name) because there are weights being created in the LSTM cells. TensorFlow will throw an error if the weights created here have the same names as the weights created in the LSTM cells, which they will be default. To avoid this, we wrap the variables in a variable scope so we can give them unique names.
Exercise
Step10: Training loss
Next up is the training loss. We get the logits and targets and calculate the softmax cross-entropy loss. First we need to one-hot encode the targets, we're getting them as encoded characters. Then, reshape the one-hot targets so it's a 2D tensor with size $(MN) \times C$ where $C$ is the number of classes/characters we have. Remember that we reshaped the LSTM outputs and ran them through a fully connected layer with $C$ units. So our logits will also have size $(MN) \times C$.
Then we run the logits and targets through tf.nn.softmax_cross_entropy_with_logits and find the mean to get the loss.
Exercise
Step11: Optimizer
Here we build the optimizer. Normal RNNs have have issues gradients exploding and disappearing. LSTMs fix the disappearance problem, but the gradients can still grow without bound. To fix this, we can clip the gradients above some threshold. That is, if a gradient is larger than that threshold, we set it to the threshold. This will ensure the gradients never grow overly large. Then we use an AdamOptimizer for the learning step.
Step12: Build the network
Now we can put all the pieces together and build a class for the network. To actually run data through the LSTM cells, we will use tf.nn.dynamic_rnn. This function will pass the hidden and cell states across LSTM cells appropriately for us. It returns the outputs for each LSTM cell at each step for each sequence in the mini-batch. It also gives us the final LSTM state. We want to save this state as final_state so we can pass it to the first LSTM cell in the the next mini-batch run. For tf.nn.dynamic_rnn, we pass in the cell and initial state we get from build_lstm, as well as our input sequences. Also, we need to one-hot encode the inputs before going into the RNN.
Exercise
Step13: Hyperparameters
Here are the hyperparameters for the network.
batch_size - Number of sequences running through the network in one pass.
num_steps - Number of characters in the sequence the network is trained on. Larger is better typically, the network will learn more long range dependencies. But it takes longer to train. 100 is typically a good number here.
lstm_size - The number of units in the hidden layers.
num_layers - Number of hidden LSTM layers to use
learning_rate - Learning rate for training
keep_prob - The dropout keep probability when training. If you're network is overfitting, try decreasing this.
Here's some good advice from Andrej Karpathy on training the network. I'm going to copy it in here for your benefit, but also link to where it originally came from.
Tips and Tricks
Monitoring Validation Loss vs. Training Loss
If you're somewhat new to Machine Learning or Neural Networks it can take a bit of expertise to get good models. The most important quantity to keep track of is the difference between your training loss (printed during training) and the validation loss (printed once in a while when the RNN is run on the validation data (by default every 1000 iterations)). In particular
Step14: Time for training
This is typical training code, passing inputs and targets into the network, then running the optimizer. Here we also get back the final LSTM state for the mini-batch. Then, we pass that state back into the network so the next batch can continue the state from the previous batch. And every so often (set by save_every_n) I save a checkpoint.
Here I'm saving checkpoints with the format
i{iteration number}_l{# hidden layer units}.ckpt
Exercise
Step15: Saved checkpoints
Read up on saving and loading checkpoints here
Step16: Sampling
Now that the network is trained, we'll can use it to generate new text. The idea is that we pass in a character, then the network will predict the next character. We can use the new one, to predict the next one. And we keep doing this to generate all new text. I also included some functionality to prime the network with some text by passing in a string and building up a state from that.
The network gives us predictions for each character. To reduce noise and make things a little less random, I'm going to only choose a new character from the top N most likely characters.
Step17: Here, pass in the path to a checkpoint and sample from the network. | Python Code:
import time
from collections import namedtuple
import numpy as np
import tensorflow as tf
Explanation: Anna KaRNNa
In this notebook, we'll build a character-wise RNN trained on Anna Karenina, one of my all-time favorite books. It'll be able to generate new text based on the text from the book.
This network is based off of Andrej Karpathy's post on RNNs and implementation in Torch. Also, some information here at r2rt and from Sherjil Ozair on GitHub. Below is the general architecture of the character-wise RNN.
<img src="assets/charseq.jpeg" width="500">
End of explanation
with open('anna.txt', 'r') as f:
text=f.read()
vocab = set(text)
vocab_to_int = {c: i for i, c in enumerate(vocab)}
int_to_vocab = dict(enumerate(vocab))
encoded = np.array([vocab_to_int[c] for c in text], dtype=np.int32)
Explanation: First we'll load the text file and convert it into integers for our network to use. Here I'm creating a couple dictionaries to convert the characters to and from integers. Encoding the characters as integers makes it easier to use as input in the network.
End of explanation
text[:100]
Explanation: Let's check out the first 100 characters, make sure everything is peachy. According to the American Book Review, this is the 6th best first line of a book ever.
End of explanation
encoded[:100]
Explanation: And we can see the characters encoded as integers.
End of explanation
len(vocab)
Explanation: Since the network is working with individual characters, it's similar to a classification problem in which we are trying to predict the next character from the previous text. Here's how many 'classes' our network has to pick from.
End of explanation
def get_batches(arr, n_seqs, n_steps):
'''Create a generator that returns batches of size
n_seqs x n_steps from arr.
Arguments
---------
arr: Array you want to make batches from
n_seqs: Batch size, the number of sequences per batch
n_steps: Number of sequence steps per batch
'''
# Get the batch size and number of batches we can make
batch_size = n_seqs * n_steps # 우리가 리턴할 batch 의 크기 (즉, 한 batch안에 몇 개의 character가 있는지)
n_batches = len(arr) // batch_size # 우리가 만들 batch 들의 갯수
# Keep only enough characters to make full batches
arr = arr[:batch_size * n_batches]
# Reshape into n_seqs rows
arr = arr.reshape((n_seqs, -1))
for n in range(0, arr.shape[1], n_steps):
# The features
x = arr[:, n:n+n_steps]
# The targets, shifted by one
y = np.zeros_like(x)
y[:, :-1], y[:, -1] = x[:, 1:], x[:, 0] # You'll usually see the first input character used as the last target character
yield x, y
Explanation: Making training mini-batches
Here is where we'll make our mini-batches for training. Remember that we want our batches to be multiple sequences of some desired number of sequence steps. Considering a simple example, our batches would look like this:
<img src="assets/[email protected]" width=500px>
<br>
We have our text encoded as integers as one long array in encoded. Let's create a function that will give us an iterator for our batches. I like using generator functions to do this. Then we can pass encoded into this function and get our batch generator.
The first thing we need to do is discard some of the text so we only have completely full batches. Each batch contains $N \times M$ characters, where $N$ is the batch size (the number of sequences) and $M$ is the number of steps. Then, to get the number of batches we can make from some array arr, you divide the length of arr by the batch size. Once you know the number of batches and the batch size, you can get the total number of characters to keep.
After that, we need to split arr into $N$ sequences. You can do this using arr.reshape(size) where size is a tuple containing the dimensions sizes of the reshaped array. We know we want $N$ sequences (n_seqs below), let's make that the size of the first dimension. For the second dimension, you can use -1 as a placeholder in the size, it'll fill up the array with the appropriate data for you. After this, you should have an array that is $N \times (M * K)$ where $K$ is the number of batches.
Now that we have this array, we can iterate through it to get our batches. The idea is each batch is a $N \times M$ window on the array. For each subsequent batch, the window moves over by n_steps. We also want to create both the input and target arrays. Remember that the targets are the inputs shifted over one character. You'll usually see the first input character used as the last target character, so something like this:
python
y[:, :-1], y[:, -1] = x[:, 1:], x[:, 0]
where x is the input batch and y is the target batch.
The way I like to do this window is use range to take steps of size n_steps from $0$ to arr.shape[1], the total number of steps in each sequence. That way, the integers you get from range always point to the start of a batch, and each window is n_steps wide.
Exercise: Write the code for creating batches in the function below. The exercises in this notebook will not be easy. I've provided a notebook with solutions alongside this notebook. If you get stuck, checkout the solutions. The most important thing is that you don't copy and paste the code into here, type out the solution code yourself.
위의 사진으로 보면
$N$ = 2 = n_seqs
$M$ = 3 = n_steps
End of explanation
batches = get_batches(encoded, 10, 50)
x, y = next(batches)
print('x\n', x[:10, :10])
print('\ny\n', y[:10, :10])
Explanation: Now I'll make my data sets and we can check out what's going on here. Here I'm going to use a batch size of 10 and 50 sequence steps.
End of explanation
def build_inputs(batch_size, num_steps):
''' Define placeholders for inputs, targets, and dropout
Arguments
---------
batch_size: Batch size, number of sequences per batch
num_steps: Number of sequence steps in a batch
'''
# Declare placeholders we'll feed into the graph
inputs = tf.placeholder(tf.int32, [batch_size, num_steps], name='inputs')
targets = tf.placeholder(tf.int32, [batch_size, num_steps], name='targets')
# Keep probability placeholder for drop out layers
keep_prob = tf.placeholder(tf.float32, name="keep_prob")
return inputs, targets, keep_prob
Explanation: If you implemented get_batches correctly, the above output should look something like
```
x
[[55 63 69 22 6 76 45 5 16 35]
[ 5 69 1 5 12 52 6 5 56 52]
[48 29 12 61 35 35 8 64 76 78]
[12 5 24 39 45 29 12 56 5 63]
[ 5 29 6 5 29 78 28 5 78 29]
[ 5 13 6 5 36 69 78 35 52 12]
[63 76 12 5 18 52 1 76 5 58]
[34 5 73 39 6 5 12 52 36 5]
[ 6 5 29 78 12 79 6 61 5 59]
[ 5 78 69 29 24 5 6 52 5 63]]
y
[[63 69 22 6 76 45 5 16 35 35]
[69 1 5 12 52 6 5 56 52 29]
[29 12 61 35 35 8 64 76 78 28]
[ 5 24 39 45 29 12 56 5 63 29]
[29 6 5 29 78 28 5 78 29 45]
[13 6 5 36 69 78 35 52 12 43]
[76 12 5 18 52 1 76 5 58 52]
[ 5 73 39 6 5 12 52 36 5 78]
[ 5 29 78 12 79 6 61 5 59 63]
[78 69 29 24 5 6 52 5 63 76]]
``
although the exact numbers will be different. Check to make sure the data is shifted over one step fory`.
Building the model
Below is where you'll build the network. We'll break it up into parts so it's easier to reason about each bit. Then we can connect them up into the whole network.
<img src="assets/charRNN.png" width=500px>
Inputs
First off we'll create our input placeholders. As usual we need placeholders for the training data and the targets. We'll also create a placeholder for dropout layers called keep_prob. This will be a scalar, that is a 0-D tensor. To make a scalar, you create a placeholder without giving it a size.
Exercise: Create the input placeholders in the function below.
End of explanation
def build_lstm(lstm_size, num_layers, batch_size, keep_prob):
''' Build LSTM cell.
Arguments
---------
keep_prob: Scalar tensor (tf.placeholder) for the dropout keep probability
lstm_size: Size of the hidden layers in the LSTM cells
num_layers: Number of LSTM layers
batch_size: Batch size
'''
### Build the LSTM Cell
# Use a basic LSTM cell
lstms = [tf.contrib.rnn.BasicLSTMCell(lstm_size) for _ in range(num_layers)]
# Add dropout to the cell outputs
drops = [tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=keep_prob) for lstm in lstms]
# Stack up multiple LSTM layers, for deep learning
cell = tf.contrib.rnn.MultiRNNCell(drops)
initial_state = cell.zero_state(batch_size, tf.float32)
return cell, initial_state
Explanation: LSTM Cell
Here we will create the LSTM cell we'll use in the hidden layer. We'll use this cell as a building block for the RNN. So we aren't actually defining the RNN here, just the type of cell we'll use in the hidden layer.
We first create a basic LSTM cell with
python
lstm = tf.contrib.rnn.BasicLSTMCell(num_units)
where num_units is the number of units in the hidden layers in the cell. Then we can add dropout by wrapping it with
python
tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=keep_prob)
You pass in a cell and it will automatically add dropout to the inputs or outputs. Finally, we can stack up the LSTM cells into layers with tf.contrib.rnn.MultiRNNCell. With this, you pass in a list of cells and it will send the output of one cell into the next cell. For example,
python
tf.contrib.rnn.MultiRNNCell([cell]*num_layers)
This might look a little weird if you know Python well because this will create a list of the same cell object. However, TensorFlow will create different weight matrices for all cell objects. Even though this is actually multiple LSTM cells stacked on each other, you can treat the multiple layers as one cell.
We also need to create an initial cell state of all zeros. This can be done like so
python
initial_state = cell.zero_state(batch_size, tf.float32)
Exercise: Below, implement the build_lstm function to create these LSTM cells and the initial state.
End of explanation
def build_output(lstm_output, in_size, out_size):
''' Build a softmax layer, return the softmax output and logits.
Arguments
---------
lstm_output: List of output tensors from the LSTM layer
in_size: Size of the input tensor, for example, size of the LSTM cells
out_size: Size of this softmax layer
'''
# Reshape output so it's a bunch of rows, one row for each step for each sequence.
# Concatenate lstm_output over axis 1 (the columns)
seq_output = tf.concat(lstm_output, axis=1)
# Reshape seq_output to a 2D tensor with lstm_size columns
x = tf.reshape(seq_output, [-1, in_size])
# Connect the RNN outputs to a softmax layer
with tf.variable_scope('softmax'):
# Create the weight and bias variables here
softmax_w = tf.Variable(tf.truncated_normal([in_size, out_size], stddev=0.1))
softmax_b = tf.Variable(tf.zeros(out_size))
# Since output is a bunch of rows of RNN cell outputs, logits will be a bunch
# of rows of logit outputs, one for each step and sequence
logits = tf.add(tf.matmul(x, softmax_w), softmax_b)
# Use softmax to get the probabilities for predicted characters
out = tf.nn.softmax(logits, name="predictions")
return out, logits
Explanation: RNN Output
Here we'll create the output layer. We need to connect the output of the RNN cells to a full connected layer with a softmax output. The softmax output gives us a probability distribution we can use to predict the next character, so we want this layer to have size $C$, the number of classes/characters we have in our text.
If our input has batch size $N$, number of steps $M$, and the hidden layer has $L$ hidden units, then the output is a 3D tensor with size $N \times M \times L$. The output of each LSTM cell has size $L$, we have $M$ of them, one for each sequence step, and we have $N$ sequences. So the total size is $N \times M \times L$.
We are using the same fully connected layer, the same weights, for each of the outputs. Then, to make things easier, we should reshape the outputs into a 2D tensor with shape $(M * N) \times L$. That is, one row for each sequence and step, where the values of each row are the output from the LSTM cells. We get the LSTM output as a list, lstm_output. First we need to concatenate this whole list into one array with tf.concat. Then, reshape it (with tf.reshape) to size $(M * N) \times L$.
One we have the outputs reshaped, we can do the matrix multiplication with the weights. We need to wrap the weight and bias variables in a variable scope with tf.variable_scope(scope_name) because there are weights being created in the LSTM cells. TensorFlow will throw an error if the weights created here have the same names as the weights created in the LSTM cells, which they will be default. To avoid this, we wrap the variables in a variable scope so we can give them unique names.
Exercise: Implement the output layer in the function below.
End of explanation
def build_loss(logits, targets, lstm_size, num_classes):
''' Calculate the loss from the logits and the targets.
Arguments
---------
logits: Logits from final fully connected layer
targets: Targets for supervised learning
lstm_size: Number of LSTM hidden units
num_classes: Number of classes in targets
'''
# One-hot encode targets and reshape to match logits, one row per sequence per step
y_one_hot = tf.one_hot(targets, num_classes)
y_reshaped = tf.reshape(y_one_hot, logits.get_shape()) # tf.reshape(y_one_hot, [-1, lstm_size])
# Softmax cross entropy loss
loss = tf.nn.softmax_cross_entropy_with_logits(labels=y_reshaped, logits=logits)
loss = tf.reduce_mean(loss)
return loss
Explanation: Training loss
Next up is the training loss. We get the logits and targets and calculate the softmax cross-entropy loss. First we need to one-hot encode the targets, we're getting them as encoded characters. Then, reshape the one-hot targets so it's a 2D tensor with size $(MN) \times C$ where $C$ is the number of classes/characters we have. Remember that we reshaped the LSTM outputs and ran them through a fully connected layer with $C$ units. So our logits will also have size $(MN) \times C$.
Then we run the logits and targets through tf.nn.softmax_cross_entropy_with_logits and find the mean to get the loss.
Exercise: Implement the loss calculation in the function below.
End of explanation
def build_optimizer(loss, learning_rate, grad_clip):
''' Build optmizer for training, using gradient clipping.
Arguments:
loss: Network loss
learning_rate: Learning rate for optimizer
'''
# Optimizer for training, using gradient clipping to control exploding gradients
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(loss, tvars), grad_clip)
train_op = tf.train.AdamOptimizer(learning_rate)
optimizer = train_op.apply_gradients(zip(grads, tvars))
return optimizer
Explanation: Optimizer
Here we build the optimizer. Normal RNNs have have issues gradients exploding and disappearing. LSTMs fix the disappearance problem, but the gradients can still grow without bound. To fix this, we can clip the gradients above some threshold. That is, if a gradient is larger than that threshold, we set it to the threshold. This will ensure the gradients never grow overly large. Then we use an AdamOptimizer for the learning step.
End of explanation
class CharRNN:
def __init__(self, num_classes, batch_size=64, num_steps=50,
lstm_size=128, num_layers=2, learning_rate=0.001,
grad_clip=5, sampling=False):
# When we're using this network for sampling later, we'll be passing in
# one character at a time, so providing an option for that
if sampling == True:
batch_size, num_steps = 1, 1
else:
batch_size, num_steps = batch_size, num_steps
tf.reset_default_graph()
# Build the input placeholder tensors
self.inputs, self.targets, self.keep_prob = build_inputs(batch_size, num_steps)
# Build the LSTM cell
cell, self.initial_state = build_lstm(lstm_size, num_layers, batch_size, self.keep_prob)
### Run the data through the RNN layers
# First, one-hot encode the input tokens
x_one_hot = tf.one_hot(self.inputs, num_classes)
# Run each sequence step through the RNN with tf.nn.dynamic_rnn
outputs, state = tf.nn.dynamic_rnn(cell, inputs=x_one_hot, initial_state=self.initial_state)
self.final_state = state
# Get softmax predictions and logits
self.prediction, self.logits = build_output(outputs, lstm_size, num_classes)
# Loss and optimizer (with gradient clipping)
self.loss = build_loss(self.logits, self.targets, lstm_size, num_classes)
self.optimizer = build_optimizer(self.loss, learning_rate, grad_clip)
Explanation: Build the network
Now we can put all the pieces together and build a class for the network. To actually run data through the LSTM cells, we will use tf.nn.dynamic_rnn. This function will pass the hidden and cell states across LSTM cells appropriately for us. It returns the outputs for each LSTM cell at each step for each sequence in the mini-batch. It also gives us the final LSTM state. We want to save this state as final_state so we can pass it to the first LSTM cell in the the next mini-batch run. For tf.nn.dynamic_rnn, we pass in the cell and initial state we get from build_lstm, as well as our input sequences. Also, we need to one-hot encode the inputs before going into the RNN.
Exercise: Use the functions you've implemented previously and tf.nn.dynamic_rnn to build the network.
End of explanation
batch_size = 100 # Sequences per batch
num_steps = 100 # Number of sequence steps per batch
lstm_size = 512 # Size of hidden layers in LSTMs
num_layers = 2 # Number of LSTM layers
learning_rate = 0.001 # Learning rate
keep_prob = 0.5 # Dropout keep probability
Explanation: Hyperparameters
Here are the hyperparameters for the network.
batch_size - Number of sequences running through the network in one pass.
num_steps - Number of characters in the sequence the network is trained on. Larger is better typically, the network will learn more long range dependencies. But it takes longer to train. 100 is typically a good number here.
lstm_size - The number of units in the hidden layers.
num_layers - Number of hidden LSTM layers to use
learning_rate - Learning rate for training
keep_prob - The dropout keep probability when training. If you're network is overfitting, try decreasing this.
Here's some good advice from Andrej Karpathy on training the network. I'm going to copy it in here for your benefit, but also link to where it originally came from.
Tips and Tricks
Monitoring Validation Loss vs. Training Loss
If you're somewhat new to Machine Learning or Neural Networks it can take a bit of expertise to get good models. The most important quantity to keep track of is the difference between your training loss (printed during training) and the validation loss (printed once in a while when the RNN is run on the validation data (by default every 1000 iterations)). In particular:
If your training loss is much lower than validation loss then this means the network might be overfitting. Solutions to this are to decrease your network size, or to increase dropout. For example you could try dropout of 0.5 and so on.
If your training/validation loss are about equal then your model is underfitting. Increase the size of your model (either number of layers or the raw number of neurons per layer)
Approximate number of parameters
The two most important parameters that control the model are lstm_size and num_layers. I would advise that you always use num_layers of either 2/3. The lstm_size can be adjusted based on how much data you have. The two important quantities to keep track of here are:
The number of parameters in your model. This is printed when you start training.
The size of your dataset. 1MB file is approximately 1 million characters.
These two should be about the same order of magnitude. It's a little tricky to tell. Here are some examples:
I have a 100MB dataset and I'm using the default parameter settings (which currently print 150K parameters). My data size is significantly larger (100 mil >> 0.15 mil), so I expect to heavily underfit. I am thinking I can comfortably afford to make lstm_size larger.
I have a 10MB dataset and running a 10 million parameter model. I'm slightly nervous and I'm carefully monitoring my validation loss. If it's larger than my training loss then I may want to try to increase dropout a bit and see if that helps the validation loss.
Best models strategy
The winning strategy to obtaining very good models (if you have the compute time) is to always err on making the network larger (as large as you're willing to wait for it to compute) and then try different dropout values (between 0,1). Whatever model has the best validation performance (the loss, written in the checkpoint filename, low is good) is the one you should use in the end.
It is very common in deep learning to run many different models with many different hyperparameter settings, and in the end take whatever checkpoint gave the best validation performance.
By the way, the size of your training and validation splits are also parameters. Make sure you have a decent amount of data in your validation set or otherwise the validation performance will be noisy and not very informative.
End of explanation
epochs = 20
# Save every N iterations
save_every_n = 200
model = CharRNN(len(vocab), batch_size=batch_size, num_steps=num_steps,
lstm_size=lstm_size, num_layers=num_layers,
learning_rate=learning_rate)
saver = tf.train.Saver(max_to_keep=100)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# Use the line below to load a checkpoint and resume training
#saver.restore(sess, 'checkpoints/______.ckpt')
counter = 0
for e in range(epochs):
# Train network
new_state = sess.run(model.initial_state)
loss = 0
for x, y in get_batches(encoded, batch_size, num_steps):
counter += 1
start = time.time()
feed = {model.inputs: x,
model.targets: y,
model.keep_prob: keep_prob,
model.initial_state: new_state}
batch_loss, new_state, _ = sess.run([model.loss,
model.final_state,
model.optimizer],
feed_dict=feed)
end = time.time()
print('Epoch: {}/{}... '.format(e+1, epochs),
'Training Step: {}... '.format(counter),
'Training loss: {:.4f}... '.format(batch_loss),
'{:.4f} sec/batch'.format((end-start)))
if (counter % save_every_n == 0):
saver.save(sess, "checkpoints/i{}_l{}.ckpt".format(counter, lstm_size))
saver.save(sess, "checkpoints/i{}_l{}.ckpt".format(counter, lstm_size))
Explanation: Time for training
This is typical training code, passing inputs and targets into the network, then running the optimizer. Here we also get back the final LSTM state for the mini-batch. Then, we pass that state back into the network so the next batch can continue the state from the previous batch. And every so often (set by save_every_n) I save a checkpoint.
Here I'm saving checkpoints with the format
i{iteration number}_l{# hidden layer units}.ckpt
Exercise: Set the hyperparameters above to train the network. Watch the training loss, it should be consistently dropping. Also, I highly advise running this on a GPU.
End of explanation
tf.train.get_checkpoint_state('checkpoints')
Explanation: Saved checkpoints
Read up on saving and loading checkpoints here: https://www.tensorflow.org/programmers_guide/variables
End of explanation
def pick_top_n(preds, vocab_size, top_n=5):
p = np.squeeze(preds)
p[np.argsort(p)[:-top_n]] = 0
p = p / np.sum(p)
c = np.random.choice(vocab_size, 1, p=p)[0]
return c
def sample(checkpoint, n_samples, lstm_size, vocab_size, prime="The "):
samples = [c for c in prime]
model = CharRNN(len(vocab), lstm_size=lstm_size, sampling=True)
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess, checkpoint)
new_state = sess.run(model.initial_state)
for c in prime:
x = np.zeros((1, 1))
x[0,0] = vocab_to_int[c]
feed = {model.inputs: x,
model.keep_prob: 1.,
model.initial_state: new_state}
preds, new_state = sess.run([model.prediction, model.final_state],
feed_dict=feed)
c = pick_top_n(preds, len(vocab))
samples.append(int_to_vocab[c])
for i in range(n_samples):
x[0,0] = c
feed = {model.inputs: x,
model.keep_prob: 1.,
model.initial_state: new_state}
preds, new_state = sess.run([model.prediction, model.final_state],
feed_dict=feed)
c = pick_top_n(preds, len(vocab))
samples.append(int_to_vocab[c])
return ''.join(samples)
Explanation: Sampling
Now that the network is trained, we'll can use it to generate new text. The idea is that we pass in a character, then the network will predict the next character. We can use the new one, to predict the next one. And we keep doing this to generate all new text. I also included some functionality to prime the network with some text by passing in a string and building up a state from that.
The network gives us predictions for each character. To reduce noise and make things a little less random, I'm going to only choose a new character from the top N most likely characters.
End of explanation
tf.train.latest_checkpoint('checkpoints')
checkpoint = tf.train.latest_checkpoint('checkpoints')
samp = sample(checkpoint, 2000, lstm_size, len(vocab), prime="Far")
print(samp)
checkpoint = 'checkpoints/i200_l512.ckpt'
samp = sample(checkpoint, 1000, lstm_size, len(vocab), prime="Far")
print(samp)
checkpoint = 'checkpoints/i600_l512.ckpt'
samp = sample(checkpoint, 1000, lstm_size, len(vocab), prime="Far")
print(samp)
checkpoint = 'checkpoints/i1200_l512.ckpt'
samp = sample(checkpoint, 1000, lstm_size, len(vocab), prime="Far")
print(samp)
Explanation: Here, pass in the path to a checkpoint and sample from the network.
End of explanation |
3,402 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Build names mapping
To make it a little easier to check that I'm using the correct guids, construct a mapping from names back to guid.
Note
Step1: Pikov Classes
These classes are the core resources used in defining a "Pikov" file.
Note
Step2: Gamekitty
Create instances of the Pikov classes to define a concrete Pikov graph, based on my "gamekitty" animations.
Load the spritesheet
In the previous notebook, we chopped the spritesheet into bitmaps. Find those and save them to an array so that they can be indexed as they were in the original PICO-8 gamekitty doodle.
Step3: Create frames for each "clip"
Each animation is defined in terms of sprite numbers. Sometimes a clip should loop, but sometimes it's only used as a transition between looping clips. | Python Code:
names = {}
for node in graph:
for edge in node:
if edge.guid == "169a81aefca74e92b45e3fa03c7021df":
value = node[edge].value
if value in names:
raise ValueError('name: "{}" defined twice'.format(value))
names[value] = node
names["ctor"]
def name_to_guid(name):
if name not in names:
return None
node = names[name]
if not hasattr(node, "guid"):
return None
return node.guid
Explanation: Build names mapping
To make it a little easier to check that I'm using the correct guids, construct a mapping from names back to guid.
Note: this adds a constraint that no two nodes have the same name, which should not be enforced for general semantic graphs.
End of explanation
from pikov.sprite import Bitmap, Clip, Frame, FrameList, Resource, Transition
Explanation: Pikov Classes
These classes are the core resources used in defining a "Pikov" file.
Note: ideally these classes could be derived from the graph itself, but I don't (yet) encode type or field information in the pikov.json semantic graph.
End of explanation
resource = Resource(graph, guid=name_to_guid("spritesheet"))
spritesheet = []
for row in range(16):
for column in range(16):
sprite_number = row * 16 + column
bitmap_name = "bitmap[{}]".format(sprite_number)
bitmap = Bitmap(graph, guid=name_to_guid(bitmap_name))
spritesheet.append(bitmap)
Explanation: Gamekitty
Create instances of the Pikov classes to define a concrete Pikov graph, based on my "gamekitty" animations.
Load the spritesheet
In the previous notebook, we chopped the spritesheet into bitmaps. Find those and save them to an array so that they can be indexed as they were in the original PICO-8 gamekitty doodle.
End of explanation
def find_nodes(graph, ctor, cls):
nodes = set()
# TODO: With graph formats that have indexes, there should be a faster way.
for node in graph:
if node[names["ctor"]] == ctor:
node = cls(graph, guid=node.guid)
nodes.add(node)
return nodes
def find_frames(graph):
return find_nodes(graph, names["frame"], Frame)
def find_transitions(graph):
return find_nodes(graph, names["transition"], Transition)
def find_absorbing_frames(graph):
transitions = find_transitions(graph)
target_frames = set()
source_frames = set()
for transition in transitions:
target_frames.add(transition.target.guid)
source_frames.add(transition.source.guid)
return target_frames - source_frames # In but not out. Dead end!
MICROS_12_FPS = int(1e6 / 12) # 12 frames per second
MICROS_24_FPS = int(1e6 / 24)
def connect_frames(graph, transition_name, source, target):
transition = Transition(graph, guid=name_to_guid(transition_name))
transition.name = transition_name
transition.source = source
transition.target = target
return transition
sit = Clip(graph, guid=name_to_guid("clip[sit]"))
sit
sit_to_stand = Clip(graph, guid=name_to_guid("clip[sit_to_stand]"))
sit_to_stand
stand_waggle= Clip(graph, guid=name_to_guid("clip[stand_waggle]"))
stand_waggle
connect_frames(
graph,
"transitions[sit_to_stand, stand_waggle]",
sit_to_stand[-1],
stand_waggle[0])
stand_to_sit = Clip(graph, guid=name_to_guid("clip[stand_to_sit]"))
stand_to_sit
connect_frames(
graph,
"transitions[stand_waggle, stand_to_sit]",
stand_waggle[-1],
stand_to_sit[0])
connect_frames(
graph,
"transitions[stand_to_sit, sit]",
stand_to_sit[-1],
sit[0])
sit_paw = Clip(graph, guid=name_to_guid("clip[sit_paw]"))
sit_paw
connect_frames(
graph,
"transitions[sit_paw, sit]",
sit_paw[-1],
sit[0])
connect_frames(
graph,
"transitions[sit, sit_paw]",
sit[-1],
sit_paw[0])
sit_to_crouch = Clip(graph, guid=name_to_guid("clip[sit_to_crouch]"))
connect_frames(
graph,
"transitions[sit, sit_to_crouch]",
sit[-1],
sit_to_crouch[0])
crouch = Clip(graph, guid=name_to_guid("clip[crouch]"))
connect_frames(
graph,
"transitions[sit_to_crouch, crouch]",
sit_to_crouch[-1],
crouch[0])
crouch_to_sit = Clip(graph, guid=name_to_guid("clip[crouch_to_sit]"))
connect_frames(
graph,
"transitions[crouch_to_sit, sit]",
crouch[-1],
crouch_to_sit[0])
connect_frames(
graph,
"transitions[crouch_to_sit, sit]",
crouch_to_sit[-1],
sit[0])
find_absorbing_frames(graph)
graph.save()
Explanation: Create frames for each "clip"
Each animation is defined in terms of sprite numbers. Sometimes a clip should loop, but sometimes it's only used as a transition between looping clips.
End of explanation |
3,403 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Quickstart
Step1: Getting filter data ready to use
If you are using wsynphot for 1st time, YOU NEED TO DOWNLOAD THE FILTER DATA by using
Step2: This will cache the filter data on your disk so that everytime you call any wsynphot function like list_filters() that requires data, the data will be accessed from cache.
Wsynphot will even remind you to update your cached filter data, when it becomes more than a month since the last update. If you want to update it at the moment, use
Step3: Listing available filters
The filter index (all available filters with their properties) can be listed as
Step4: Filter Curve
Create a filter curve object
Step5: Plot the curve by plot() method
Step6: Do any required calculations on the filter curve object | Python Code:
import wsynphot
Explanation: Quickstart
End of explanation
# wsynphot.download_filter_data()
Explanation: Getting filter data ready to use
If you are using wsynphot for 1st time, YOU NEED TO DOWNLOAD THE FILTER DATA by using:
End of explanation
# wsynphot.update_filter_data()
Explanation: This will cache the filter data on your disk so that everytime you call any wsynphot function like list_filters() that requires data, the data will be accessed from cache.
Wsynphot will even remind you to update your cached filter data, when it becomes more than a month since the last update. If you want to update it at the moment, use:
End of explanation
wsynphot.list_filters()
Explanation: Listing available filters
The filter index (all available filters with their properties) can be listed as:
End of explanation
filter = wsynphot.FilterCurve.load_filter('Keck/NIRC2/Kp')
filter
Explanation: Filter Curve
Create a filter curve object:
End of explanation
%matplotlib inline
import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (9,6)
filter.plot(plt.gca())
Explanation: Plot the curve by plot() method:
End of explanation
filter.zp_vega_f_lambda
filter.convert_vega_magnitude_to_f_lambda(0)
filter.convert_vega_magnitude_to_f_lambda(14.5)
Explanation: Do any required calculations on the filter curve object:
End of explanation |
3,404 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Predicting Seminal Quality from Environmental and Lifestyle Factors
Fertility Data Set
Downloaded from the UCI Machine Learning Repository on July 10, 2019. The dataset description is as follows
Step2: Data Ingestion from the UCI repository
Here we are retrieving dat from the UCI repository. We do this by
Step3: We use df.describe to get a summary of our data. We can see that there is no missing data because the "count" for each attribute is 100.
We see that there are 88 instances of normal diagnosis (N) and 12 instances of altered
diagnosis (O). This tells us class imbalance may be an issue because there are far more instances of normal diagnoses than altered. We've learned that most machine learning algorithms work best when the number of instances of each classes are roughly equal.
Now let's plot some of the other attributes to get a sense of the frequency distribution.
Step4: These graphs show us that most analyses were preformed in the winter, spring, and fall. Very few were preformed in the summer.
We also can see that way more participants didn't have a childhood disease, whereas 18 reported they did.
We also see most of the participants "have one drink a week" or "hardly ever".
Data Wrangling
Here we're using Scikit-Learn transformers to prepare data for ML. The sklearn.preprocessing package provides utility functions and transformer classes to help us transform input data so that it is better suited for ML. Here we're using LabelEncoder to encode the "diagnosis" variable with a value between 0 and n_classes-1 (in our case, 1).
Step5: Data Visualization
Here we're using Pandas to create various visualizations of our data.
First, we're creating a matrix of scatter plots of the features in our dataset. This is useful for understanding how our features interact with eachother. I'm not sure I'm sensing any valuable insight from the scatter matrix below.
Step6: Next, we use parallel coordinates, another approach to analyzing multivariate data. Each line represents an instance from the dataset and the value of the instance for each of the features. The color represents the category of diagnosis. This gives us some insight to common trends of the various color categories. For example, we can see that occasional smokers (0) spend more hours sitting compared to non-smokers (-1).
Step7: Then, we create a radial plot, which normalizes our data and plots the instances relative to our features. This is useful for us to look for clusters and trends happening in the multivariate layer of our dataset. Similar to how a scatter plot shows the interplay of two features this reflects the interaction of a higher dimension of features. While not conclusive, it appears that instances of normal diagnoses are gravitating more toward surgical_intervention.
Step8: Data Extraction
One way that we can structure our data for easy management is to save files on disk. The Scikit-Learn datasets are already structured this way, and when loaded into a Bunch (a class imported from the datasets module of Scikit-Learn) we can expose a data API that is very familiar to how we've trained on our toy datasets in the past. A Bunch object exposes some important properties
Step9: Data Loading and Management
Define a function to load data
Construct the Bunch object for the data set by defining the paths and file names
Load the features and labels from the meta data
Load the read me description
Use Pandas to load data from the txt file
Extract the target from the data by indexing with column names
Create a 'Bunch' object, which is a dictionary that exposes dictionary keys as properties so that you can access them with dot notation.
Step10: Classification
Now that we have a dataset Bunch loaded and ready, we can begin the classification process. Let's attempt to build a classifier with kNN, SVM, and Random Forest classifiers.
Load the Algorithms!
Metrics for evaluating performance
K-Folds cross-validator provides train/test indices to split data in train/test sets.
SVC algorithm
K Neighbors Classifier
Random Forest Classifier
Logistic Regression
Step12: Define a function to evaluate the performance of the models
Set our start time
Define an empty array for our scores variable
Define our training dataset and our test dataset
Define estimator and fit to data
Define predictor and set to data
Calculate metrics for evaluating models
Print evaluation report
Write estimator to disc for future predictions
Save model | Python Code:
import os
import json
import time
import pickle
import requests
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
from yellowbrick.features import Rank2D
%matplotlib inline
Explanation: Predicting Seminal Quality from Environmental and Lifestyle Factors
Fertility Data Set
Downloaded from the UCI Machine Learning Repository on July 10, 2019. The dataset description is as follows:
Data Set: Multivariate
Attribute: Real
Tasks: Classification, Regression
Instances: 100
Attributes: 10
Data Set Information:
Fertility rates have dramatically decreased in the last two decades, especially in men. Literature indicates that environmental factors, as well as lifestyle habits, may affect semen quality. Typically semen quality is assessed in a lab but this procedure is expensive. In this paper, researchers set out to test whether AI techniques could accurately predict the seminal profile of an individual based on environmental factors and life habits.
100 volunteers between 18 and 36 years old participated in the study. They were asked to provide a semen sample and complete a questionnaire about life habits and health status.
The data set can be used for the tasks of classification and regression analysis.
Attribute Information:
There are nine attributes in the dataset:
Season in which the analysis was performed. 1) winter, 2) spring, 3) Summer, 4) fall. (-1, -0.33, 0.33, 1)
Age at the time of analysis. 18-36 (0, 1)
Childish diseases 1) yes, 2) no. (0, 1)
Accident or serious trauma 1) yes, 2) no. (0, 1)
Surgical intervention 1) yes, 2) no. (0, 1)
High fevers in the last year 1) less than three months ago, 2) more than three months ago, 3) no. (-1, 0, 1)
Frequency of alcohol consumption 1) several times a day, 2) every day, 3) several times a week, 4) once a week, 5) hardly ever or never (0, 1)
Smoking habit 1) never, 2) occasional 3) daily. (-1, 0, 1)
Number of hours spent sitting per day ene-16 (0, 1)
Output: Diagnosis normal (N), altered (O)
Input data has been converted into a range of normalization according to the follow rules:
1. Numerical variables such as "age" are normalized onto the interval (0, 1). For instance, "age" has a range between the minimum 18 and the maximum 36. This means that the persons that is 36 years old is normalized to the value 1 whereas an individual that is 27 is normalized to the value 9/18 = 0.50.
2. The variables with only two independent attributes ("childish diseases","accident","surgical intervention","number of hours sitting") are pre-arranged with binary values (0, 1).
3. The variables with three independent attributes, such as "High fevers in the last year" and "Smoking habit" are prearranged using the ternary values(-1,0,1).** For example, "Smoking habit" will take -1 for never, 0 represents occasional and 1 daily.
4. The variables with four independent attributes, such as‘‘Season in which the analysis was performed’’ are prearranged using the four different and equaldistance values (-1,-0.33,0.33,1).
Relevant Papers:
Gil, D., Girela, J. L., De Juan, J., Gomez-Torres, M. J., & Johnsson, M. (2012). Predicting seminal quality with artificial intelligence methods. Expert Systems with Applications, 39(16), 12564-12573.
Data Exploration and Visualization
In this section we will begin to explore the dataset to determine relevant information.
End of explanation
URL = "https://archive.ics.uci.edu/ml/machine-learning-databases/00244/fertility_Diagnosis.txt"
def fetch_data(fname='fertility_Diagnosis.txt'):
Helper method to retreive the ML Repository dataset.
response = requests.get(URL)
outpath = os.path.abspath(fname)
with open(outpath, 'wb') as f:
f.write(response.content)
return outpath
# Fetch the data if required
DATA = fetch_data()
# Here we define the features of the dataset and use panda's read CSV function to read
# the data into a DataFrame, df
FEATURES = [
"season_of_analysis", #(winter=-1,spring=-0.33,summer=.33,fall=1)
"age", #18-36(0,1)
"childhood_disease",#(yes=0,no=1)
"accident_or_trauma",#(yes=0,no=1)
"surgical_intervention",#(yes=0,no=1)
"high_fevers",#(less than three months ago=-1, more than three months ago=0, no=1)
"alcohol",#several times a day, every day, several times a week, once a week, hardly ever or never(0,1)
"smoking",#never=-1, occasional=0, daily=1
"hours_sitting", #1-16(0,1)
"diagnosis"
]
LABEL_MAP = {
0: "Normal_Diagnosis",
1: "Altered_Diagnosis",
}
# Read the data into a DataFrame
df = pd.read_csv(DATA, sep=',', header= None, names=FEATURES)
# Taking a closer look at the data
df.head()
# Describe the dataset
print(df.describe())
# Determine the shape of the data
print("{} instances with {} features\n".format(*df.shape))
# Determine the frequency of each class of diagnosis
print(df.groupby('diagnosis')['diagnosis'].count())
Explanation: Data Ingestion from the UCI repository
Here we are retrieving dat from the UCI repository. We do this by:
- Write a function using os and requests
- Define the URL
- Define the file name
- Define the location
- Execute the function to fetch the data and save as CSV
End of explanation
plt.figure(figsize=(4,3))
sns.countplot(data = df, x = 'season_of_analysis')
plt.figure(figsize=(4,3))
sns.countplot(data = df, x = 'childhood_disease')
plt.figure(figsize=(4,3))
sns.countplot(data = df, x = 'alcohol')
Explanation: We use df.describe to get a summary of our data. We can see that there is no missing data because the "count" for each attribute is 100.
We see that there are 88 instances of normal diagnosis (N) and 12 instances of altered
diagnosis (O). This tells us class imbalance may be an issue because there are far more instances of normal diagnoses than altered. We've learned that most machine learning algorithms work best when the number of instances of each classes are roughly equal.
Now let's plot some of the other attributes to get a sense of the frequency distribution.
End of explanation
from sklearn.preprocessing import LabelEncoder
# Extract our X and y data
X = df[FEATURES[:-1]]
y = df["diagnosis"]
# Encode our target variable
encoder = LabelEncoder().fit(y)
y = encoder.transform(y)
print(X.shape, y.shape)
Explanation: These graphs show us that most analyses were preformed in the winter, spring, and fall. Very few were preformed in the summer.
We also can see that way more participants didn't have a childhood disease, whereas 18 reported they did.
We also see most of the participants "have one drink a week" or "hardly ever".
Data Wrangling
Here we're using Scikit-Learn transformers to prepare data for ML. The sklearn.preprocessing package provides utility functions and transformer classes to help us transform input data so that it is better suited for ML. Here we're using LabelEncoder to encode the "diagnosis" variable with a value between 0 and n_classes-1 (in our case, 1).
End of explanation
# Create a scatter matrix of the dataframe features using Pandas
from pandas.plotting import scatter_matrix
scatter_matrix(df, alpha=0.2, figsize=(12, 12), diagonal='kde')
plt.show()
Explanation: Data Visualization
Here we're using Pandas to create various visualizations of our data.
First, we're creating a matrix of scatter plots of the features in our dataset. This is useful for understanding how our features interact with eachother. I'm not sure I'm sensing any valuable insight from the scatter matrix below.
End of explanation
from pandas.plotting import parallel_coordinates
plt.figure(figsize=(12,12))
parallel_coordinates(df, 'diagnosis', color =('#556270','#4ECDC4'))
plt.show()
Explanation: Next, we use parallel coordinates, another approach to analyzing multivariate data. Each line represents an instance from the dataset and the value of the instance for each of the features. The color represents the category of diagnosis. This gives us some insight to common trends of the various color categories. For example, we can see that occasional smokers (0) spend more hours sitting compared to non-smokers (-1).
End of explanation
from yellowbrick.features import RadViz
_ = RadViz(classes=encoder.classes_, alpha=0.35).fit_transform_poof(X, y)
Explanation: Then, we create a radial plot, which normalizes our data and plots the instances relative to our features. This is useful for us to look for clusters and trends happening in the multivariate layer of our dataset. Similar to how a scatter plot shows the interplay of two features this reflects the interaction of a higher dimension of features. While not conclusive, it appears that instances of normal diagnoses are gravitating more toward surgical_intervention.
End of explanation
from sklearn.datasets.base import Bunch
DATA_DIR = os.path.abspath(os.path.join( ".", "..", "mollymorrison1670", 'Data'))
print(DATA_DIR)
# Show the contents of the data directory
for name in os.listdir(DATA_DIR):
if name.startswith("."): continue
print("- {}".format(name))
Explanation: Data Extraction
One way that we can structure our data for easy management is to save files on disk. The Scikit-Learn datasets are already structured this way, and when loaded into a Bunch (a class imported from the datasets module of Scikit-Learn) we can expose a data API that is very familiar to how we've trained on our toy datasets in the past. A Bunch object exposes some important properties:
- data: array of shape n_samples * n_features
- target: array of length n_samples
- feature_names: names of the features
- target_names: names of the targets
- filenames: names of the files that were loaded
- DESCR: contents of the readme
In order to manage our data set on disk, we'll structure our data as follows:
End of explanation
def load_data(root=DATA_DIR):
# Construct the `Bunch` for the fertility dataset
filenames = {
'meta': os.path.join(root, 'meta.json'),
'rdme': os.path.join(root, 'README.md'),
'data': os.path.join(root, 'fertility_diagnosis.txt'),
}
# Load the meta data from the meta json
with open(filenames['meta'], 'r') as f:
meta = json.load(f)
target_names = meta['target_names']
feature_names = meta['feature_names']
# Load the description from the README.
with open(filenames['rdme'], 'r') as f:
DESCR = f.read()
# Load the dataset from the text file.
dataset = pd.read_csv('fertility_Diagnosis.txt', delimiter=',', names=FEATURES)
# 'diagnosis' is stored as a text value. We convert (or 'map') it into numeric binaries
# so it will be ready for scikit-learn.
dataset.diagnosis = dataset.diagnosis.map({'N': 0,'O': 1})
# Extract the target from the data
data = dataset[['season_of_analysis', 'age', 'childhood_disease', 'accident_or_trauma', 'surgical_intervention',
'high_fevers', 'alcohol', 'smoking', 'hours_sitting']]
target = dataset['diagnosis']
# Create the bunch object
return Bunch(
data=data,
target=target,
filenames=filenames,
target_names=target_names,
feature_names=feature_names,
DESCR=DESCR
)
# Save the dataset as a variable we can use.
dataset = load_data()
print(dataset.data.shape)
print(dataset.target.shape)
Explanation: Data Loading and Management
Define a function to load data
Construct the Bunch object for the data set by defining the paths and file names
Load the features and labels from the meta data
Load the read me description
Use Pandas to load data from the txt file
Extract the target from the data by indexing with column names
Create a 'Bunch' object, which is a dictionary that exposes dictionary keys as properties so that you can access them with dot notation.
End of explanation
from sklearn import metrics
from sklearn.model_selection import KFold
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
Explanation: Classification
Now that we have a dataset Bunch loaded and ready, we can begin the classification process. Let's attempt to build a classifier with kNN, SVM, and Random Forest classifiers.
Load the Algorithms!
Metrics for evaluating performance
K-Folds cross-validator provides train/test indices to split data in train/test sets.
SVC algorithm
K Neighbors Classifier
Random Forest Classifier
Logistic Regression
End of explanation
def fit_and_evaluate(dataset, model, label, **kwargs):
Because of the Scikit-Learn API, we can create a function to
do all of the fit and evaluate work on our behalf!
start = time.time() # Start the clock!
scores = {'precision':[], 'recall':[], 'accuracy':[], 'f1':[]}
kf = KFold(n_splits = 12, shuffle=True)
for train, test in kf.split(dataset.data):
X_train, X_test = dataset.data.iloc[train], dataset.data.iloc[test]
y_train, y_test = dataset.target.iloc[train], dataset.target.iloc[test]
estimator = model(**kwargs)
estimator.fit(X_train, y_train)
expected = y_test
predicted = estimator.predict(X_test)
# Append our scores to the tracker
scores['precision'].append(metrics.precision_score(expected, predicted, average="weighted"))
scores['recall'].append(metrics.recall_score(expected, predicted, average="weighted"))
scores['accuracy'].append(metrics.accuracy_score(expected, predicted))
scores['f1'].append(metrics.f1_score(expected, predicted, average="weighted"))
# Report
print("Build and Validation of {} took {:0.3f} seconds".format(label, time.time()-start))
print("Validation scores are as follows:\n")
print(pd.DataFrame(scores).mean())
# Write official estimator to disk in order to use for future predictions on new data
estimator = model(**kwargs)
estimator.fit(dataset.data, dataset.target)
#saving model with the pickle model
outpath = label.lower().replace(" ", "-") + ".pickle"
with open(outpath, 'wb') as f:
pickle.dump(estimator, f)
print("\nFitted model written to:\n{}".format(os.path.abspath(outpath)))
# Perform SVC Classification
fit_and_evaluate(dataset, SVC, "Fertility SVM Classifier", gamma = 'auto')
# Perform kNN Classification
fit_and_evaluate(dataset, KNeighborsClassifier, "Fertility kNN Classifier", n_neighbors=12)
# Perform Random Forest Classification
fit_and_evaluate(dataset, RandomForestClassifier, "Fertility Random Forest Classifier")
fit_and_evaluate(dataset, LogisticRegression , "Fertility Logistic Regression")
Explanation: Define a function to evaluate the performance of the models
Set our start time
Define an empty array for our scores variable
Define our training dataset and our test dataset
Define estimator and fit to data
Define predictor and set to data
Calculate metrics for evaluating models
Print evaluation report
Write estimator to disc for future predictions
Save model
End of explanation |
3,405 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Доверительные интервалы на основе bootstrap
Step1: Загрузка данных
Время ремонта телекоммуникаций
Verizon — основная региональная телекоммуникационная компания (Incumbent Local Exchange Carrier, ILEC) в западной
части США. В связи с этим данная компания обязана предоставлять сервис ремонта телекоммуникационного оборудования
не только для своих клиентов, но и для клиентов других локальных телекоммуникационых компаний (Competing Local Exchange Carriers, CLEC). При этом в случаях, когда время ремонта оборудования для клиентов других компаний существенно выше, чем для собственных, Verizon может быть оштрафована.
Step2: Bootstrap
Step3: Интервальная оценка медианы
Step4: Точечная оценка разности медиан
Step5: Интервальная оценка разности медиан | Python Code:
import numpy as np
import pandas as pd
%pylab inline
Explanation: Доверительные интервалы на основе bootstrap
End of explanation
data = pd.read_csv('verizon.txt', sep='\t')
data.shape
data.head()
data.Group.value_counts()
pylab.figure(figsize(12, 5))
pylab.subplot(1,2,1)
pylab.hist(data[data.Group == 'ILEC'].Time, bins = 20, color = 'b', range = (0, 100), label = 'ILEC')
pylab.legend()
pylab.subplot(1,2,2)
pylab.hist(data[data.Group == 'CLEC'].Time, bins = 20, color = 'r', range = (0, 100), label = 'CLEC')
pylab.legend()
pylab.show()
Explanation: Загрузка данных
Время ремонта телекоммуникаций
Verizon — основная региональная телекоммуникационная компания (Incumbent Local Exchange Carrier, ILEC) в западной
части США. В связи с этим данная компания обязана предоставлять сервис ремонта телекоммуникационного оборудования
не только для своих клиентов, но и для клиентов других локальных телекоммуникационых компаний (Competing Local Exchange Carriers, CLEC). При этом в случаях, когда время ремонта оборудования для клиентов других компаний существенно выше, чем для собственных, Verizon может быть оштрафована.
End of explanation
def get_bootstrap_samples(data, n_samples):
indices = np.random.randint(0, len(data), (n_samples, len(data)))
samples = data[indices]
return samples
def stat_intervals(stat, alpha):
boundaries = np.percentile(stat, [100 * alpha / 2., 100 * (1 - alpha / 2.)])
return boundaries
Explanation: Bootstrap
End of explanation
ilec_time = data[data.Group == 'ILEC'].Time.values
clec_time = data[data.Group == 'CLEC'].Time.values
np.random.seed(0)
ilec_median_scores = map(np.median, get_bootstrap_samples(ilec_time, 1000))
clec_median_scores = map(np.median, get_bootstrap_samples(clec_time, 1000))
print "95% confidence interval for the ILEC median repair time:", stat_intervals(ilec_median_scores, 0.05)
print "95% confidence interval for the CLEC median repair time:", stat_intervals(clec_median_scores, 0.05)
Explanation: Интервальная оценка медианы
End of explanation
print "difference between medians:", np.median(clec_time) - np.median(ilec_time)
Explanation: Точечная оценка разности медиан
End of explanation
delta_median_scores = map(lambda x: x[1] - x[0], zip(ilec_median_scores, clec_median_scores))
print "95% confidence interval for the difference between medians", stat_intervals(delta_median_scores, 0.05)
Explanation: Интервальная оценка разности медиан
End of explanation |
3,406 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Table of Contents
<p><div class="lev1"><a href="#How-to-create-and-populate-a-histogram"><span class="toc-item-num">1 </span>How to create and populate a histogram</a></div><div class="lev1"><a href="#What-does-a-hist()-fucntion-returns?"><span class="toc-item-num">2 </span>What does a hist() fucntion returns?</a></div><div class="lev1"><a href="#Manipulate-The-Histogram-Aesthetics"><span class="toc-item-num">3 </span>Manipulate The Histogram Aesthetics</a></div><div class="lev2"><a href="#Number-of-bins"><span class="toc-item-num">3.1 </span>Number of bins</a></div><div class="lev2"><a href="#Range-of-histogram"><span class="toc-item-num">3.2 </span>Range of histogram</a></div><div class="lev2"><a href="#Normalizing-your-histogram"><span class="toc-item-num">3.3 </span>Normalizing your histogram</a></div><div class="lev3"><a href="#Special-Normalize"><span class="toc-item-num">3.3.1 </span>Special Normalize</a></div><div class="lev2"><a href="#Weights-of-your-input"><span class="toc-item-num">3.4 </span>Weights of your input</a></div><div class="lev2"><a href="#Cumulative-histogram"><span class="toc-item-num">3.5 </span>Cumulative histogram</a></div><div class="lev2"><a href="#Raise-your-histogram-using-bottom"><span class="toc-item-num">3.6 </span>Raise your histogram using bottom</a></div><div class="lev2"><a href="#Different-draw-types"><span class="toc-item-num">3.7 </span>Different draw types</a></div><div class="lev2"><a href="#Align-of-the-histogram"><span class="toc-item-num">3.8 </span>Align of the histogram</a></div><div class="lev2"><a href="#Orientation-of-the-bins"><span class="toc-item-num">3.9 </span>Orientation of the bins</a></div><div class="lev2"><a href="#Relative-width-of-the-bars"><span class="toc-item-num">3.10 </span>Relative width of the bars</a></div><div class="lev2"><a href="#Logarithmic-Scale"><span class="toc-item-num">3.11 </span>Logarithmic Scale</a></div><div class="lev2"><a href="#Color-of-your-histogram"><span class="toc-item-num">3.12 </span>Color of your histogram</a></div><div class="lev2"><a href="#Label-your-histogram"><span class="toc-item-num">3.13 </span>Label your histogram</a></div><div class="lev2"><a href="#Stack-multiple-histograms"><span class="toc-item-num">3.14 </span>Stack multiple histograms</a></div><div class="lev2"><a href="#Add-Info-about-the-data-on-the-canvas"><span class="toc-item-num">3.15 </span>Add Info about the data on the canvas</a></div><div class="lev1"><a href="#How-to-fit-a-histogram"><span class="toc-item-num">4 </span>How to fit a histogram</a></div><div class="lev2"><a href="#Fit-using-Kernel-Density-Estimation"><span class="toc-item-num">4.1 </span>Fit using Kernel Density Estimation</a></div><div class="lev2"><a href="#Fit-using-Scipy's-Optimize-submodule"><span class="toc-item-num">4.2 </span>Fit using Scipy's Optimize submodule</a></div><div class="lev3"><a href="#Example-of-curve-fit-
Step1: Let's generate a data array
Step2: Make a histogram of the data
Step3: What does a hist() fucntion returns?
We can use the hist() function and assign it to a tuple of size 3 to get back some information about what the histogram does.
The whole output is
Step4: In this case
Step5: my_bins
Step6: my_patches
Step7: Manipulate The Histogram Aesthetics
Number of bins
Use the bins= option.
Step8: Range of histogram
Use the range=(tuple) option
Step9: Normalizing your histogram
To normalize a histogram use the normed=True option.
Step10: This assures that the integral of the distribution is equal to unity.
If stacked is also True, the sum of the histograms is normalized to 1.
Special Normalize
However, sometimes it is useful to visualize the height of the bins to sum up to unity.
For this we generate weights for the histogram. Each bin has the weight
Step11: Weights of your input
To weight your data use the weights=(array) option.
The weights array must be of the same shape of the data provided.
Each data point provided in the data array only contributes its associated weight towards the bin count (instead of 1)
If you also use normed=True the weights will be normalized so that the integral of the density over the range is unity.
Again, sometimes it is useful to visualize the height of the bins to sum up to unity.
For this we generate weights for the histogram. Each bin has the weight
Step12: Cumulative histogram
This is to create the cumulative histogram. Use cimulative=True, so that now each bin has its counts and also all the counts of the previous bins.
Step13: Raise your histogram using bottom
You can raise your histogram by adding either a scalar (fixed) amount on your y-axis, or even an array-like raise.
To do this use the bottom=(array,scalar,None) option
Step14: Different draw types
Use the histtype= option for other draw options of your histogram. Basics are
Step15: barstacked -> bar-type where multiple data are stacked on-top of the other
Step16: step -> To create the line plot only
Step17: stepfilled -> to create the step but also fill it (similar to bar but without the vertical lines)
Step18: Align of the histogram
One can use the align='left'|'mid'|'right' option
'left' -> bars are centered on the left bin edges
Step19: 'mid' -> bars centered between bin edges
Step20: 'right' -> guess...
Step21: Orientation of the bins
You can orient the histogram vertical or horizontal using the orientation option.
Step22: Relative width of the bars
The option rwidth=(scalar,None) defines the relative width of the bars as a fraction of the bin width. If None (default) automatically computes the width.
Step23: Logarithmic Scale
To enable the logarithmic scale use the log=True option. The histogram axis will be set to log scale. For logarithmic histograms, empty bins are filtered out.
Step24: Color of your histogram
You can use the presets or array_like of colors.
Step25: Label your histogram
Use the label=string option. This takes a string or a sequence of strings.
Step26: Stack multiple histograms
To stack more than one histogram use the stacked=True option.
If True multiple data are stacked on top of each other, otherwise, if False multiple data are aranged side by side (or on-top of each other)
Step27: Add Info about the data on the canvas
First of all we can get the mean, median, std of the data plotted and add them on the canvas
Step28: Then create the string and add these values
Step29: Or using a textbox...
Step30: How to fit a histogram
Let's generate a normal distribution
Step31: Assume now that seeing these data we think that a gaussian distribution will fit the best on the given dataset.
We load the gaussian (normal) distribution from scipy.stats
Step32: Now, looking at this function norm we see it has the loc option and the scale option.
loc is the mean value and scale the standard deviation
To fit a gaussian on top of the histogram, we need the normed histogram and also to get the mean and std of the gaussian that fits the data. Therefore we have
Step33: Then we create the curve for that using the norm.pdf in the range of fit_data.min() and fit_data.max()
Step34: Fit using Kernel Density Estimation
Instead of specifying a distribution we can fit the best probability density function. This can be achieved thanks to the non-parametric techique of kernel density estimation.
KDE is a non parametric way to estimate the probability density function of a random variable.
How it works?
Suppose $(x_1, x_2, ..., x_n)$ are i.i.d. with unknown density $f$. We want to estimate the shape of this function $f$. Its kernel density estimator is
$ \hat{f}{h}(x) = \frac{1}{n} \sum{i=1}^{n}(x-x_i) = \frac{1}{nh}\sum_{i=1}^{n}K\left(\frac{x-x_i}{h}\right)$
where the $K()$ is the kernel. Kernel is a non-negative function that intergrates to one and has mean zero, also h>0 is a smoothing parameter called bandwidth.
A kernel with a subscript h is called a scaled kernel and is defined as $K_h(x)=\frac{1}{h}K(\frac{x}{h})$.
Usually one wants to use small $h$, but is always a trade of between the bias of the estimator and its variance.
Kernel functions commonly used
Step35: N.B.
Step36: Curve fit on histogram
To use curve_fit on a histogram we need to get the bin heights and model the histogram as a set of data points. One way to do it is to take the height of the center bin as (x,y) datapoints.
Step37: What about the fit errors?
To get the standard deviation of the parameters simply get the square root of the sum of the diagonal elements of the covariance matrix. | Python Code:
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
Explanation: Table of Contents
<p><div class="lev1"><a href="#How-to-create-and-populate-a-histogram"><span class="toc-item-num">1 </span>How to create and populate a histogram</a></div><div class="lev1"><a href="#What-does-a-hist()-fucntion-returns?"><span class="toc-item-num">2 </span>What does a hist() fucntion returns?</a></div><div class="lev1"><a href="#Manipulate-The-Histogram-Aesthetics"><span class="toc-item-num">3 </span>Manipulate The Histogram Aesthetics</a></div><div class="lev2"><a href="#Number-of-bins"><span class="toc-item-num">3.1 </span>Number of bins</a></div><div class="lev2"><a href="#Range-of-histogram"><span class="toc-item-num">3.2 </span>Range of histogram</a></div><div class="lev2"><a href="#Normalizing-your-histogram"><span class="toc-item-num">3.3 </span>Normalizing your histogram</a></div><div class="lev3"><a href="#Special-Normalize"><span class="toc-item-num">3.3.1 </span>Special Normalize</a></div><div class="lev2"><a href="#Weights-of-your-input"><span class="toc-item-num">3.4 </span>Weights of your input</a></div><div class="lev2"><a href="#Cumulative-histogram"><span class="toc-item-num">3.5 </span>Cumulative histogram</a></div><div class="lev2"><a href="#Raise-your-histogram-using-bottom"><span class="toc-item-num">3.6 </span>Raise your histogram using bottom</a></div><div class="lev2"><a href="#Different-draw-types"><span class="toc-item-num">3.7 </span>Different draw types</a></div><div class="lev2"><a href="#Align-of-the-histogram"><span class="toc-item-num">3.8 </span>Align of the histogram</a></div><div class="lev2"><a href="#Orientation-of-the-bins"><span class="toc-item-num">3.9 </span>Orientation of the bins</a></div><div class="lev2"><a href="#Relative-width-of-the-bars"><span class="toc-item-num">3.10 </span>Relative width of the bars</a></div><div class="lev2"><a href="#Logarithmic-Scale"><span class="toc-item-num">3.11 </span>Logarithmic Scale</a></div><div class="lev2"><a href="#Color-of-your-histogram"><span class="toc-item-num">3.12 </span>Color of your histogram</a></div><div class="lev2"><a href="#Label-your-histogram"><span class="toc-item-num">3.13 </span>Label your histogram</a></div><div class="lev2"><a href="#Stack-multiple-histograms"><span class="toc-item-num">3.14 </span>Stack multiple histograms</a></div><div class="lev2"><a href="#Add-Info-about-the-data-on-the-canvas"><span class="toc-item-num">3.15 </span>Add Info about the data on the canvas</a></div><div class="lev1"><a href="#How-to-fit-a-histogram"><span class="toc-item-num">4 </span>How to fit a histogram</a></div><div class="lev2"><a href="#Fit-using-Kernel-Density-Estimation"><span class="toc-item-num">4.1 </span>Fit using Kernel Density Estimation</a></div><div class="lev2"><a href="#Fit-using-Scipy's-Optimize-submodule"><span class="toc-item-num">4.2 </span>Fit using Scipy's Optimize submodule</a></div><div class="lev3"><a href="#Example-of-curve-fit-:"><span class="toc-item-num">4.2.1 </span>Example of curve fit :</a></div><div class="lev3"><a href="#Curve-fit-on-histogram"><span class="toc-item-num">4.2.2 </span>Curve fit on histogram</a></div><div class="lev2"><a href="#What-about-the-fit-errors?"><span class="toc-item-num">4.3 </span>What about the fit errors?</a></div><div class="lev3"><a href="#How-can-I-be-sure-about-my-fit-errors?"><span class="toc-item-num">4.3.1 </span>How can I be sure about my fit errors?</a></div>
# How to create and populate a histogram
End of explanation
data = np.random.rand(500)*1200;
Explanation: Let's generate a data array
End of explanation
fig = plt.figure();
plt.hist(data)
plt.show()
Explanation: Make a histogram of the data
End of explanation
n, my_bins, my_patches = plt.hist(data, bins=10);
Explanation: What does a hist() fucntion returns?
We can use the hist() function and assign it to a tuple of size 3 to get back some information about what the histogram does.
The whole output is :
End of explanation
n
len(n)
Explanation: In this case:
n : is an array or a list of arrays that hold the values of the histogram bins. (Careful in case of the weights and/or normed options are used.
End of explanation
my_bins
Explanation: my_bins : Is an array. This holds the edges of the bins. The length of the my_bins is nbins+1 (that is nbins left edges and the right edge of the last bin). This is always a single array, even if more than one datasets are passed in.
End of explanation
my_patches
Explanation: my_patches : This is a silent list of the individual patches that are used to create the histogram or list of such list if multiple datasets are plotted.
End of explanation
plt.hist(data, bins=100);
Explanation: Manipulate The Histogram Aesthetics
Number of bins
Use the bins= option.
End of explanation
plt.hist(data, bins=100, range=(0,1000));
Explanation: Range of histogram
Use the range=(tuple) option
End of explanation
plt.hist(data, normed=True);
Explanation: Normalizing your histogram
To normalize a histogram use the normed=True option.
End of explanation
weights = np.ones_like(data)/len(data);
plt.hist(data, weights=weights); ## We have NOT used the normed = True option
Explanation: This assures that the integral of the distribution is equal to unity.
If stacked is also True, the sum of the histograms is normalized to 1.
Special Normalize
However, sometimes it is useful to visualize the height of the bins to sum up to unity.
For this we generate weights for the histogram. Each bin has the weight: 1/(number of data points)
N.B. : Using this technique you MUST NOT USE the normed=True option.
This way adding up the bars will give you 1.
End of explanation
weights = np.ones_like(data)/len(data);
plt.hist(data, weights=weights);
Explanation: Weights of your input
To weight your data use the weights=(array) option.
The weights array must be of the same shape of the data provided.
Each data point provided in the data array only contributes its associated weight towards the bin count (instead of 1)
If you also use normed=True the weights will be normalized so that the integral of the density over the range is unity.
Again, sometimes it is useful to visualize the height of the bins to sum up to unity.
For this we generate weights for the histogram. Each bin has the weight: 1/(number of data points)
N.B. : Using this technique you MUST NOT USE the normed=True option.
This way adding up the bars will give you 1.
End of explanation
plt.hist(data, weights=weights, cumulative=True);
Explanation: Cumulative histogram
This is to create the cumulative histogram. Use cimulative=True, so that now each bin has its counts and also all the counts of the previous bins.
End of explanation
plt.hist(data, weights=weights, bottom=5);
nbins = 10
bot = 5*np.random.rand(nbins)
plt.hist(data, bins=nbins, bottom=bot);
Explanation: Raise your histogram using bottom
You can raise your histogram by adding either a scalar (fixed) amount on your y-axis, or even an array-like raise.
To do this use the bottom=(array,scalar,None) option
End of explanation
plt.hist(data, bins=nbins,histtype='bar');
Explanation: Different draw types
Use the histtype= option for other draw options of your histogram. Basics are:
bar -> Traditional bar type histogram
End of explanation
plt.hist(data, bins=nbins,histtype='barstacked');
Explanation: barstacked -> bar-type where multiple data are stacked on-top of the other
End of explanation
plt.hist(data, bins=nbins,histtype='step');
Explanation: step -> To create the line plot only
End of explanation
plt.hist(data, bins=nbins,histtype='stepfilled');
Explanation: stepfilled -> to create the step but also fill it (similar to bar but without the vertical lines)
End of explanation
plt.hist(data, align='left');
Explanation: Align of the histogram
One can use the align='left'|'mid'|'right' option
'left' -> bars are centered on the left bin edges
End of explanation
plt.hist(data, align='mid');
Explanation: 'mid' -> bars centered between bin edges
End of explanation
plt.hist(data, align='right');
Explanation: 'right' -> guess...
End of explanation
plt.hist(data, orientation="horizontal");
plt.hist(data, orientation="vertical");
Explanation: Orientation of the bins
You can orient the histogram vertical or horizontal using the orientation option.
End of explanation
plt.hist(data);
plt.hist(data, rwidth=0.2);
plt.hist(data, rwidth=0.8);
Explanation: Relative width of the bars
The option rwidth=(scalar,None) defines the relative width of the bars as a fraction of the bin width. If None (default) automatically computes the width.
End of explanation
plt.hist(data, log=True);
Explanation: Logarithmic Scale
To enable the logarithmic scale use the log=True option. The histogram axis will be set to log scale. For logarithmic histograms, empty bins are filtered out.
End of explanation
plt.hist(data, color='red');
plt.hist(data, color=[0.2, 0.3, 0.8, 0.3]); # RGBA
Explanation: Color of your histogram
You can use the presets or array_like of colors.
End of explanation
plt.hist(data, label="Histogram");
Explanation: Label your histogram
Use the label=string option. This takes a string or a sequence of strings.
End of explanation
data2 = np.random.rand(500)*1300;
plt.hist(data, stacked=True);
plt.hist(data2, stacked=True);
Explanation: Stack multiple histograms
To stack more than one histogram use the stacked=True option.
If True multiple data are stacked on top of each other, otherwise, if False multiple data are aranged side by side (or on-top of each other)
End of explanation
entries = len(data);
mean = data.mean();
stdev = data.std();
Explanation: Add Info about the data on the canvas
First of all we can get the mean, median, std of the data plotted and add them on the canvas
End of explanation
textstr = 'Entries=$%i$\nMean=$%.2f$\n$\sigma$=$%.2f$'%(entries, mean, stdev)
plt.hist(data, label=textstr);
plt.ylim(0,100);
plt.legend(loc='best',markerscale=0.01);
Explanation: Then create the string and add these values
End of explanation
plt.hist(data);
plt.ylim(0,100);
#plt.text(800,80,textstr);
plt.annotate(textstr, xy=(0.7, 0.8), xycoords='axes fraction') # annotate for specifying the
# fraction of the canvas
Explanation: Or using a textbox...
End of explanation
fit_data = np.random.randn(500)*200;
plt.hist(fit_data);
Explanation: How to fit a histogram
Let's generate a normal distribution
End of explanation
from scipy.stats import norm
Explanation: Assume now that seeing these data we think that a gaussian distribution will fit the best on the given dataset.
We load the gaussian (normal) distribution from scipy.stats:
End of explanation
plt.hist(fit_data, normed=True);
mean, std = norm.fit(fit_data);
mean
std
Explanation: Now, looking at this function norm we see it has the loc option and the scale option.
loc is the mean value and scale the standard deviation
To fit a gaussian on top of the histogram, we need the normed histogram and also to get the mean and std of the gaussian that fits the data. Therefore we have
End of explanation
x = np.linspace(fit_data.min(), fit_data.max(), 1000);
fit_gaus_func = norm.pdf(x, mean, std);
plt.hist(fit_data, normed=True);
plt.plot(x,fit_gaus_func, lw=4);
Explanation: Then we create the curve for that using the norm.pdf in the range of fit_data.min() and fit_data.max()
End of explanation
from scipy.stats import gaussian_kde
pdf_gaus = gaussian_kde(fit_data);
pdf_gaus
pdf_gaus = pdf_gaus.evaluate(x); # get the "y" values from the pdf for the "x" axis, this is an array
pdf_gaus
plt.hist(fit_data, normed=1);
plt.plot(x, pdf_gaus, 'k', lw=3)
plt.plot(x,fit_gaus_func, lw=4, label="fit");
plt.plot(x, pdf_gaus, 'k', lw=3, label="KDE");
plt.legend();
Explanation: Fit using Kernel Density Estimation
Instead of specifying a distribution we can fit the best probability density function. This can be achieved thanks to the non-parametric techique of kernel density estimation.
KDE is a non parametric way to estimate the probability density function of a random variable.
How it works?
Suppose $(x_1, x_2, ..., x_n)$ are i.i.d. with unknown density $f$. We want to estimate the shape of this function $f$. Its kernel density estimator is
$ \hat{f}{h}(x) = \frac{1}{n} \sum{i=1}^{n}(x-x_i) = \frac{1}{nh}\sum_{i=1}^{n}K\left(\frac{x-x_i}{h}\right)$
where the $K()$ is the kernel. Kernel is a non-negative function that intergrates to one and has mean zero, also h>0 is a smoothing parameter called bandwidth.
A kernel with a subscript h is called a scaled kernel and is defined as $K_h(x)=\frac{1}{h}K(\frac{x}{h})$.
Usually one wants to use small $h$, but is always a trade of between the bias of the estimator and its variance.
Kernel functions commonly used:
- uniform
- triangular
- biweight
- triweight
- Epanechinikov
- normal
More under https://en.wikipedia.org/wiki/Kernel_(statistics)#Kernel_functions_in_common_use
In python this is done using the scipy.stats.kde submodule.
For gaussian kernel density estimation we use the gaussian kde
End of explanation
from scipy.optimize import curve_fit
## define the model function:
def func(x, a,b,c):
return a*np.exp(-b*x)+c
## the x-points
xdata = np.linspace(0,4,50);
## get some data from the model function...
y = func(xdata, 2.5, 1.3, 0.5)
##and then add some gaussian errors to generate the "data"
ydata = y + 0.2*np.random.normal(size=len(xdata))
## now run the curve_fit()
popt, pcov = curve_fit(func, xdata, ydata)
popt
pcov
### To constrain the optimization to the region of 0<a<3.0 , 0<b<2 and 0<c<1
popt, pcov = curve_fit(func, xdata, ydata, bounds=(0, [3., 2., 1.]))
popt
pcov
Explanation: N.B.: Notice the difference in the two fit curves! This comes from the fact that the Gaussian kernel is a mixture of normal distrubutions; a Gaussian mixture may be skew or heavy-, light-tailed or multimodal. Thus it does not assume the original distrubution of any particular form.
Fit using Scipy's Optimize submodule
Scipy comes with an optimize submodule that provides several commonly used optimization algorithms.
One of the easiest is curve_fit, which uses non-linear least squares to fit a function $f$ to the data. It assumes that :
$ y_{data} = f(x_{data}, *params) + eps$
The declaration of the function is :
scipy.optimize.curve_fit(f, xdata, ydata, p0=None, sigma=None, absolute_sigma=False, check_finite=True, bounds=(-inf, inf), method=None, jac=None, **kwargs)
where
- f : model function (callable) f(x, ... ) the independent variable must be its first argument
- xdata : sequence or array (array (k,M) when we have multiple funcitons with k predictors)
- ydata : sequence of dependent data
- p0 : initial guess for the parameters
- sigma : if it is not set to None this provides the uncertainties in the ydata array. These are used as weights in the LSquere problem, i.e. minimizing : $\sum{\left(\frac{f(xdata, popt)-ydata}{sigma}\right)^2}$. If set to None, uncertainties are assumed to be 1.
-absolute_sigma : (bool) When False, sigma denotes relative weights of datapoints. The returned covariance matrix is based on estimated errors in the data and is not affected by the overall magnitude of the values in sigma. Only the relative magnitudes of the sigma values matter. If true, then sigma describes one standard deviation errors of the input data points. The estimated covariance in pcov is based on these values.
- method : 'lm', 'trf', 'dogbox' (N.B.: lm does not work when the number of observations is less than the number of variables)
The function returns
- popt : array of optimal values for the parameters so that the sum of the squared error of $f(xdata, popt)-ydata$ is minimized
pcov : the covariance matrix of popot. To compute one standard deviation errors on the parameters use :
$$ perr = np.sqrt(np.diag(pcov)) $$
Errors raised by the module:
- ValueError : if there are any NaN's or incompatible options used
- RuntimeError : if least squares minimization fails
- OptimizeWarning : if covariance of the parameters cannot be estimated.
Example of curve fit :
End of explanation
### Start with the histogram, but now get the values and binEdges
n,bins,patches = plt.hist(fit_data, bins=10);
n
bins
### Calculate the bin centers as (bins[1:]+bins[:-1])/2
binCenters = 0.5 * (bins[1:] + bins[:-1]); # we throw away the first (in the first) and last (in the second) edge
binCenters
## function to model is a gaussian:
def func_g(x, a, b, c):
return a*np.exp(-(x-b)**2/(2*c**2))
## xdata are the centers, ydata are the values
xdata = binCenters
ydata = n
popt, pcov = curve_fit(func_g, xdata, ydata, p0=[1, ydata.mean(), ydata.std()])#,diag=(1./xdata.mean(),1./ydata.mean())) # setting some initial guesses to "help" the minimizer
popt
pcov
plt.plot(xdata,ydata, "ro--", lw=2, label="Data Bin Center");
plt.hist(fit_data, bins=10, label="Data Hist");
plt.plot(np.linspace(xdata.min(),xdata.max(),100),
func_g(np.linspace(xdata.min(),xdata.max(),100),popt[0],popt[1],popt[2]),
"g-", lw=3, label="Fit"); # I increased the x axis points to have smoother curve
plt.legend();
Explanation: Curve fit on histogram
To use curve_fit on a histogram we need to get the bin heights and model the histogram as a set of data points. One way to do it is to take the height of the center bin as (x,y) datapoints.
End of explanation
errors = []
for i in range(len(popt)):
try:
errors.append(np.absolute(pcov[i][i])**0.5)
except:
errors.append(0.00)
for i in range(len(popt)):
print popt[i],"+/-",errors[i]
Explanation: What about the fit errors?
To get the standard deviation of the parameters simply get the square root of the sum of the diagonal elements of the covariance matrix.
End of explanation |
3,407 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Test 2016-06-13
문제 1.
다음 데이터는 뉴욕시의 레스토랑을 평가한 자료이다. 각 열은 다음과 같은 의미를 가진다.
Case
Step1: 이 데이터를 이용하여 저녁 식사 가격을 예측하는 선형 회귀 모형을 작성하고 다음 질문에 답하라 (주의 사항
Step2: t-검정의 유의 확률이 가장 큰 것은 Service
동부에 위치한 프리미엄은 East의 계수, 즉 약 2 달러 (2.0681)
Step3: C(East)의 ANOVA 유의 확률은 0.0001371938 이므로 유의하다.
문제 2
다음 데이터를 이용하여 자동차의 가격을 결정하기 위한 모형을 작성하라. 각 열은 다음과 같은 의미를 가진다.
EngineSize
Step4: 답
Step5: -상관계수 값이 0.9가 넘어갈 경우는 현실세계에서 보통 없다.
-넘어간 경우는 보통 mean값을 0을 안주고 구한 경우. R스퀘어 값이 크게 나온다. bias를 고려하지 않았기 때문
Step6: 결과에서 LogWheelBase 와 LogHighwayMPG 생략 | Python Code:
df1 = pd.read_csv("nyc.csv", encoding = "ISO-8859-1")
df1.head(2)
Explanation: Test 2016-06-13
문제 1.
다음 데이터는 뉴욕시의 레스토랑을 평가한 자료이다. 각 열은 다음과 같은 의미를 가진다.
Case: 레스토랑 번호
Restaurant: 레스토랑 이름
Price: 저녁 식사 가격 (US$)
Food: 식사에 대한 고객 평가 점수 (1~30)
Decor: 인테리어에 대한 고객 평가 점수 (1~30)
Service: 서비스에 대한 고객 평가 점수 (1~30)
East: 뉴욕 동부에 위치한 경우 1, 아니면 0
End of explanation
model1 = sm.OLS.from_formula("Price ~ Food + Decor + Service + C(East)", data=df1)
result1 = model1.fit()
print(result1.summary())
#1부터 30이라서 굳이 스케일링을 하지 않아도 되는 문제였다.
Explanation: 이 데이터를 이용하여 저녁 식사 가격을 예측하는 선형 회귀 모형을 작성하고 다음 질문에 답하라 (주의 사항: from_formula 메서드를 사용하여 작성할 것)
가격을 결정하는데 가장 영향력이 작은 요인은 무엇인가? t-검정을 통해 확인하라.
뉴욕 동부에 위치한 결과로 생기는 가격 프리미엄은 얼마인가? 이 값이 추가적인 의미가 있는지를 확인하는 ANOVA 분석을 실시하라. (유의 수준 1%)
답
다음과 같은 점에 유의하여 모형을 작성했는지 검토
모든 feature가 같은 스케일을 가지고 있으므로 별도의 스케일은 필요없다.
East 는 category 값이므로 C() 를 사용한다.
End of explanation
sm.stats.anova_lm(result1)
#Food의 F값이 가장 크기 때문에 영향력이 가장 크다.
Explanation: t-검정의 유의 확률이 가장 큰 것은 Service
동부에 위치한 프리미엄은 East의 계수, 즉 약 2 달러 (2.0681)
End of explanation
df20 = pd.read_csv("cars04.csv")
df2 = df20[["EngineSize", "Cylinders", "Horsepower", "HighwayMPG", "Weight", "WheelBase", "Hybrid", "SuggestedRetailPrice"]]
df2.head(2)
Explanation: C(East)의 ANOVA 유의 확률은 0.0001371938 이므로 유의하다.
문제 2
다음 데이터를 이용하여 자동차의 가격을 결정하기 위한 모형을 작성하라. 각 열은 다음과 같은 의미를 가진다.
EngineSize: 엔진 배기량
Cylinders: 실린더 수
Horsepower: 마력
HighwayMPG: 연비
Weight: 중량
WheelBase: 축간 거리
Hybrid: 하이브리드 차량이면 1
SuggestedRetailPrice: 권장 소비자 가격
모형 작성시 다음과 같은 순서로 작성하라
각 요인을 그대로 사용한 모형(model1)을 작성한다.
요인에 대한 스케일링 및 변환이 필요한 경우 이를 고려한 새로운 모형(model2)을 작성한다.
새로운 모형은 Adjusted R-squared 0.8 이상, condition number가 1000 이하
Adjusted R-squared 를 최대화
End of explanation
model2 = sm.OLS.from_formula("SuggestedRetailPrice ~ EngineSize + Cylinders + Horsepower + HighwayMPG + Weight + WheelBase + C(Hybrid)", data=df2)
result2 = model2.fit()
print(result2.summary())
sns.pairplot(df2)
plt.show()
df30 = pd.DataFrame(index=df2.index)
df30["EngineSize"] = df2.EngineSize
df30["LogCylinders"] = np.log(df2.Cylinders)
df30["LogHorsepower"] = np.log(df2.Horsepower)
df30["LogHighwayMPG"] = np.log(df2.HighwayMPG)
df30["Weight"] = df2.Weight
df30["LogWheelBase"] = np.log(df2.WheelBase)
df30["Hybrid"] = df2.Hybrid
df30["LogSuggestedRetailPrice"] = np.log(df2.SuggestedRetailPrice)
# sns.pairplot(df30)
# plt.show;
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler(with_mean=False)
df3 = pd.DataFrame(scaler.fit_transform(df30), columns=df30.columns)
#다항변환은 로그변환에 포함이 된다. 그래서 일반적으로 하는 것은 로그를 취하면 된다.
model3 = sm.OLS.from_formula("LogSuggestedRetailPrice ~ EngineSize + LogCylinders + LogHorsepower + LogHighwayMPG + Weight + LogWheelBase + C(Hybrid)", data=df3)
result3 = model3.fit()
print(result3.summary())
Explanation: 답
End of explanation
sm.stats.anova_lm(result3)
Explanation: -상관계수 값이 0.9가 넘어갈 경우는 현실세계에서 보통 없다.
-넘어간 경우는 보통 mean값을 0을 안주고 구한 경우. R스퀘어 값이 크게 나온다. bias를 고려하지 않았기 때문
End of explanation
model4 = sm.OLS.from_formula("LogSuggestedRetailPrice ~ EngineSize + LogCylinders + LogHorsepower + Weight + C(Hybrid)", data=df3)
result4 = model4.fit()
print(result4.summary())
Explanation: 결과에서 LogWheelBase 와 LogHighwayMPG 생략
End of explanation |
3,408 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
The Duffing Oscillator
In this notebook we will explore the Duffing Oscillator and attempt to recreate the time traces and phase portraits shown on the Duffing Oscillator Wikipedia page
Step2: Specifying the Dynamical System
Now let's specify the right hand side of our dynamical system. It should be
$$
\ddot x + \delta\dot x + \alpha x + \beta x^3 = \gamma\cos(\omega t)
$$
But desolver only works with first order differential equations, thus we must cast this into a first order system before we can solve it. Thus we obtain the following system
$$
\begin{array}{l}
\frac{\mathrm{d}x}{\mathrm{dt}} = v_x \
\frac{\mathrm{d}v_x}{\mathrm{dt}} = -\delta v_x - \alpha x - \beta x^3 + \gamma\cos(\omega t)
\end{array}
$$
Step3: Let's specify the initial conditions as well
Step4: And now we're ready to integrate!
The Numerical Integration
We will use the same constants from Wikipedia as our constants where the forcing amplitude increases and all the other parameters stay constants.
Step5: Plotting the State and Phase Portrait
Step6: We can see that this plot looks near identical to this plot.
$$\gamma=0.20$$
Integrating for Different Values of Gamma
Now let's try to recreate the other plots with the varying gamma values. | Python Code:
%matplotlib inline
from matplotlib import pyplot as plt
import desolver as de
import desolver.backend as D
D.set_float_fmt('float64')
Explanation: The Duffing Oscillator
In this notebook we will explore the Duffing Oscillator and attempt to recreate the time traces and phase portraits shown on the Duffing Oscillator Wikipedia page
End of explanation
@de.rhs_prettifier(
equ_repr="[vx, -𝛿*vx - α*x - β*x**3 + γ*cos(ω*t)]",
md_repr=r
$$
\begin{array}{l}
\frac{\mathrm{d}x}{\mathrm{dt}} = v_x \\
\frac{\mathrm{d}v_x}{\mathrm{dt}} = -\delta v_x - \alpha x - \beta x^3 + \gamma\cos(\omega t)
\end{array}
$$
)
def rhs(t, state, delta, alpha, beta, gamma, omega, **kwargs):
x,vx = state
return D.stack([
vx,
-delta*vx - alpha*x - beta*x**3 + gamma*D.cos(omega*t)
])
print(rhs)
display(rhs)
Explanation: Specifying the Dynamical System
Now let's specify the right hand side of our dynamical system. It should be
$$
\ddot x + \delta\dot x + \alpha x + \beta x^3 = \gamma\cos(\omega t)
$$
But desolver only works with first order differential equations, thus we must cast this into a first order system before we can solve it. Thus we obtain the following system
$$
\begin{array}{l}
\frac{\mathrm{d}x}{\mathrm{dt}} = v_x \
\frac{\mathrm{d}v_x}{\mathrm{dt}} = -\delta v_x - \alpha x - \beta x^3 + \gamma\cos(\omega t)
\end{array}
$$
End of explanation
y_init = D.array([1., 0.])
Explanation: Let's specify the initial conditions as well
End of explanation
#Let's define the fixed constants
constants = dict(
delta = 0.3,
omega = 1.2,
alpha = -1.0,
beta = 1.0
)
# The period of the system
T = 2*D.pi / constants['omega']
# Initial and Final integration times
t0 = 0.0
tf = 40 * T
a = de.OdeSystem(rhs, y0=y_init, dense_output=True, t=(t0, tf), dt=0.01, rtol=1e-12, atol=1e-12, constants={**constants})
a.method = "RK87"
a.reset()
a.constants['gamma'] = 0.2
a.integrate()
Explanation: And now we're ready to integrate!
The Numerical Integration
We will use the same constants from Wikipedia as our constants where the forcing amplitude increases and all the other parameters stay constants.
End of explanation
# Times to evaluate the system at
eval_times = D.linspace(18.1, 38.2, 1000)*T
from matplotlib import gridspec
fig = plt.figure(figsize=(20, 4))
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
ax0 = fig.add_subplot(gs[0])
ax1 = fig.add_subplot(gs[1])
ax1.set_aspect(1)
ax0.plot(eval_times/T, a.sol(eval_times)[:, 0])
ax0.set_xlim(18.1, 38.2)
ax0.set_ylim(0, 1.4)
ax0.set_xlabel(r"$t/T$")
ax0.set_ylabel(r"$x$")
ax0.set_title(r"$\gamma={}$".format(a.constants['gamma']))
ax1.plot(a[18*T:].y[:, 0], a[18*T:].y[:, 1])
ax1.scatter(a[18*T:].y[-1:, 0], a[18*T:].y[-1:, 1], c='red', s=25, zorder=10)
ax1.set_xlim(-1.6, 1.6)
ax1.set_ylim(-1.6, 1.6)
ax1.set_xlabel(r"$x$")
ax1.set_ylabel(r"$\dot x$")
ax1.grid(which='major')
plt.tight_layout()
Explanation: Plotting the State and Phase Portrait
End of explanation
gamma_values = [0.28, 0.29, 0.37, 0.5, 0.65]
integration_results = []
for gamma in gamma_values:
a.reset()
a.constants['gamma'] = gamma
if gamma == 0.5:
a.tf = 80.*T
eval_times = D.linspace(18.1, 78.2, 3000)*T
integer_period_multiples = D.arange(19, 78)*T
else:
a.tf = 40.*T
eval_times = D.linspace(18.1, 38.2, 1000)*T
integer_period_multiples = D.arange(19, 38)*T
a.integrate()
integration_results.append(((eval_times, a.sol(eval_times)), a.sol(integer_period_multiples)))
for gamma, ((state_times, states), period_states) in zip(gamma_values, integration_results):
fig = plt.figure(figsize=(20, 4))
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
ax0 = fig.add_subplot(gs[0])
ax1 = fig.add_subplot(gs[1])
ax1.set_aspect(1)
ax0.plot(state_times/T, states[:, 0], zorder=9)
ax0.set_xlim(state_times[0]/T, state_times[-1]/T)
if gamma < 0.37:
ax0.set_ylim(0, 1.4)
else:
ax0.set_ylim(-1.6, 1.6)
ax0.axhline(0, color='k', linewidth=0.5)
ax0.set_xlabel(r"$t/T$")
ax0.set_ylabel(r"$x$")
ax0.set_title(r"$\gamma={}$".format(gamma))
ax1.plot(states[:, 0], states[:, 1])
ax1.scatter(period_states[:, 0], period_states[:, 1], c='red', s=25, zorder=10)
ax1.set_xlim(-1.6, 1.6)
ax1.set_ylim(-1.6, 1.6)
ax1.set_xlabel(r"$x$")
ax1.set_ylabel(r"$\dot x$")
ax1.grid(which='major')
plt.tight_layout()
Explanation: We can see that this plot looks near identical to this plot.
$$\gamma=0.20$$
Integrating for Different Values of Gamma
Now let's try to recreate the other plots with the varying gamma values.
End of explanation |
3,409 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
LAB 01
Step1: Check that the Google BigQuery library is installed and if not, install it.
Step2: The source dataset
Our dataset is hosted in BigQuery. The taxi fare data is a publically available dataset, meaning anyone with a GCP account has access. Click here to acess the dataset.
Create a BigQuery Dataset and Google Cloud Storage Bucket
A BigQuery dataset is a container for tables, views, and models built with BigQuery ML. Let's create one called feat_eng if we have not already done so in an earlier lab. We'll do the same for a GCS bucket for our project too.
Step3: Create the training data table
Since there is already a publicly available dataset, we can simply create the training data table. Note the WHERE clause in the below query
Step4: Verify table creation
Verify that you created the dataset.
Step5: Benchmark Model
Step6: REMINDER
Step7: NOTE
Step8: Model 1
Step9: Once the training is done, visit the BigQuery Cloud Console and look at the model that has been trained. Then, come back to this notebook.
Exercise
Step10: Create the SQL statements to review model_1 training information.
Exercise
Step11: Model 2
Step12: Exercise
Step13: Model 3
Step14: Exercise
Step15: Model 4
Step16: Exercise
Step17: LAB 02
Step18: Exercise
Step19: Model 6
Step20: Exercise
Step21: Code Clean Up
Exercise
Step22: LAB 03
Step23: Exercise
Step24: Final Model
Step25: Exercise
Step26: LAB 04
Step27: Exercise
Step28: What can you conclude when the feature passengers is removed from the prediction model?
ANSWER
Step29: Exercise | Python Code:
%%bash
export PROJECT=$(gcloud config list project --format "value(core.project)")
echo "Your current GCP Project Name is: "$PROJECT
import os
PROJECT = "cloud-training-demos" # REPLACE WITH YOUR PROJECT NAME
REGION = "us-west1-b" # REPLACE WITH YOUR BUCKET REGION e.g. us-central1
# Do not change these
os.environ["PROJECT"] = PROJECT
os.environ["REGION"] = REGION
os.environ["BUCKET"] = PROJECT # DEFAULT BUCKET WILL BE PROJECT ID
if PROJECT == "your-gcp-project-here":
print("Don't forget to update your PROJECT name! Currently:", PROJECT)
Explanation: LAB 01: Applying Feature Engineering to BigQuery ML Models
Learning Objectives
Setup up the environment
Create the project dataset
Create the feature engineering training table
Create and evaluate the benchmark/baseline model
Extract numeric features
Perform a feature cross
Evaluate model performance
Introduction
In this notebook, we utilize feature engineering to improve the prediction of the fare amount for a taxi ride in New York City. We will use BigQuery ML to build a taxifare prediction model, using feature engineering to improve and create a final model.
In this lab we set up the environment, create the project dataset, create a feature engineering table, create and evaluate a benchmark model, extract numeric features, perform a feature cross and evaluate model performance.
Each learning objective will correspond to a #TODO in this student lab notebook -- try to complete this notebook first and then review the solution notebook. NOTE TO SELF: UPDATE HYPERLINK.
Set up environment variables and load necessary libraries
End of explanation
!pip freeze | grep google-cloud-bigquery==1.6.1 || pip install google-cloud-bigquery==1.6.1
Explanation: Check that the Google BigQuery library is installed and if not, install it.
End of explanation
%%bash
## Create a BigQuery dataset for feat_eng_TEST if it doesn't exist
datasetexists=$(bq ls -d | grep -w feat_eng)
if [ -n "$datasetexists" ]; then
echo -e "BigQuery dataset already exists, let's not recreate it."
else
echo "Creating BigQuery dataset titled: feat_eng"
bq --location=US mk --dataset \
--description 'Taxi Fare' \
$PROJECT:feat_eng
echo "\nHere are your current datasets:"
bq ls
fi
## Create GCS bucket if it doesn't exist already...
exists=$(gsutil ls -d | grep -w gs://${PROJECT}/)
if [ -n "$exists" ]; then
echo -e "Bucket exists, let's not recreate it."
else
echo "Creating a new GCS bucket."
gsutil mb -l ${REGION} gs://${PROJECT}
echo "\nHere are your current buckets:"
gsutil ls
fi
Explanation: The source dataset
Our dataset is hosted in BigQuery. The taxi fare data is a publically available dataset, meaning anyone with a GCP account has access. Click here to acess the dataset.
Create a BigQuery Dataset and Google Cloud Storage Bucket
A BigQuery dataset is a container for tables, views, and models built with BigQuery ML. Let's create one called feat_eng if we have not already done so in an earlier lab. We'll do the same for a GCS bucket for our project too.
End of explanation
%%bigquery
CREATE OR REPLACE TABLE feat_eng.feateng_training_data
AS
SELECT
(tolls_amount + fare_amount) AS fare_amount,
passenger_count*1.0 AS passengers,
pickup_datetime,
pickup_longitude AS pickuplon,
pickup_latitude AS pickuplat,
dropoff_longitude AS dropofflon,
dropoff_latitude AS dropofflat
FROM `nyc-tlc.yellow.trips`
WHERE MOD(ABS(FARM_FINGERPRINT(CAST(pickup_datetime AS STRING))), 10000) = 1
AND fare_amount >= 2.5
AND passenger_count > 0
AND pickup_longitude > -78
AND pickup_longitude < -70
AND dropoff_longitude > -78
AND dropoff_longitude < -70
AND pickup_latitude > 37
AND pickup_latitude < 45
AND dropoff_latitude > 37
AND dropoff_latitude < 45
Explanation: Create the training data table
Since there is already a publicly available dataset, we can simply create the training data table. Note the WHERE clause in the below query: This clause allows us to TRAIN a portion of the data (e.g. one million rows versus a billion rows), which keeps your query costs down.
Note: The dataset in the create table code below is the one created previously, e.g. "feat_eng". The table name is "feateng_training_data".
Exercise: RUN the query to create the table.
End of explanation
%%bigquery
-- LIMIT 0 is a free query; this allows us to check that the table exists.
SELECT * FROM feat_eng.feateng_training_data
LIMIT 0
Explanation: Verify table creation
Verify that you created the dataset.
End of explanation
%%bigquery
# TODO:
%%bigquery
# SOLUTION
CREATE OR REPLACE MODEL feat_eng.benchmark_model
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
pickup_datetime,
pickuplon,
pickuplat,
dropofflon,
dropofflat FROM feat_eng.feateng_training_data
Explanation: Benchmark Model: Create the benchmark/baseline Model
Next, you create a linear regression baseline model with no feature engineering. Recall that a model in BigQuery ML represents what an ML system has learned from the training data. A baseline model is a solution to a problem without applying any machine learning techniques.
When creating a BQML model, you must specify the model type (in our case linear regression) and the input label (fare_amount). Note also that we are using the training data table as the data source.
Exercise: Create the SQL statement to create the model "Benchmark Model".
End of explanation
%%bigquery
#Eval statistics on the held out data.
SELECT *, SQRT(loss) AS rmse FROM ML.TRAINING_INFO(MODEL feat_eng.benchmark_model)
%%bigquery
SELECT * FROM ML.EVALUATE(MODEL feat_eng.benchmark_model)
Explanation: REMINDER: The query takes several minutes to complete. After the first iteration is complete, your model (benchmark_model) appears in the navigation panel of the BigQuery web UI. Because the query uses a CREATE MODEL statement to create a model, you do not see query results.
You can observe the model as it's being trained by viewing the Model stats tab in the BigQuery web UI. As soon as the first iteration completes, the tab is updated. The stats continue to update as each iteration completes.
Once the training is done, visit the BigQuery Cloud Console and look at the model that has been trained. Then, come back to this notebook.
Evaluate the benchmark model
Note that BigQuery automatically split the data we gave it, and trained on only a part of the data and used the rest for evaluation. After creating your model, you evaluate the performance of the regressor using the ML.EVALUATE function. The ML.EVALUATE function evaluates the predicted values against the actual data.
NOTE: The results are also displayed in the BigQuery Cloud Console under the Evaluation tab.
Exercise: Review the learning and eval statistics for the benchmark_model.
End of explanation
%%bigquery
# TODO
%%bigquery
#SOLUTION
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.benchmark_model)
Explanation: NOTE: Because you performed a linear regression, the results include the following columns:
mean_absolute_error
mean_squared_error
mean_squared_log_error
median_absolute_error
r2_score
explained_variance
Resource for an explanation of the regression metrics: Regression Metrics
Mean squared error (MSE) - Measures the difference between the values our model predicted using the test set and the actual values. You can also think of it as the distance between your regression (best fit) line and the predicted values.
Root mean squared error (RMSE) - The primary evaluation metric for this ML problem is the root mean-squared error. RMSE measures the difference between the predictions of a model, and the observed values. A large RMSE is equivalent to a large average error, so smaller values of RMSE are better. One nice property of RMSE is that the error is given in the units being measured, so you can tell very directly how incorrect the model might be on unseen data.
R2: An important metric in the evaluation results is the R2 score. The R2 score is a statistical measure that determines if the linear regression predictions approximate the actual data. 0 indicates that the model explains none of the variability of the response data around the mean. 1 indicates that the model explains all the variability of the response data around the mean.
Exercise: Write a SQL query to take the SQRT() of the mean squared error as your loss metric for evaluation for the benchmark_model.
End of explanation
# TODO
%%bigquery
#SOLUTION
CREATE OR REPLACE MODEL feat_eng.model_1
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
pickup_datetime,
EXTRACT(DAYOFWEEK FROM pickup_datetime) AS dayofweek,
pickuplon,
pickuplat,
dropofflon,
dropofflat FROM feat_eng.feateng_training_data
Explanation: Model 1: EXTRACT DayOfWeek from the pickup_datetime feature.
As you recall, DayOfWeek is an enum representing the 7 days of the week. This factory allows the enum to be obtained from the int value. The int value follows the ISO-8601 standard, from 1 (Monday) to 7 (Sunday).
Exercise: EXTRACT DayOfWeek from the pickup_datetime feature.
Create a model titled "model_1" from the benchmark model and extract out the DayofWeek.
End of explanation
#Create the SQL statements to extract Model_1 TRAINING metrics.
# TODO: Your code goes here
#Create the SQL statements to extract Model_1 EVALUATION metrics.
# TODO: Your code goes here
%%bigquery
SELECT *, SQRT(loss) AS rmse FROM ML.TRAINING_INFO(MODEL feat_eng.model_1)
%%bigquery
SELECT * FROM ML.EVALUATE(MODEL feat_eng.model_1)
Explanation: Once the training is done, visit the BigQuery Cloud Console and look at the model that has been trained. Then, come back to this notebook.
Exercise: Create two distinct SQL statements to see the TRAINING and EVALUATION metrics of model_1.
End of explanation
#Create the SQL statement to EVALUATE Model_1 here.
# TODO: Your code goes here
%%bigquery
#SOLUTION
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.model_1)
Explanation: Create the SQL statements to review model_1 training information.
Exercise: Write a SQL query to take the SQRT() of the mean squared error as your loss metric for evaluation for model_1.
End of explanation
# TODO:
%%bigquery
#SOLUTION
CREATE OR REPLACE MODEL feat_eng.model_2
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
#pickup_datetime,
EXTRACT(DAYOFWEEK FROM pickup_datetime) AS dayofweek,
EXTRACT(HOUR FROM pickup_datetime) AS hourofday,
pickuplon,
pickuplat,
dropofflon,
dropofflat
FROM `feat_eng.feateng_training_data`
Explanation: Model 2: EXTRACT hourofday from the pickup_datetime feature
As you recall, pickup_datetime is stored as a TIMESTAMP, where the Timestamp format is retrieved in the standard output format – year-month-day hour:minute:second (e.g. 2016-01-01 23:59:59). Hourofaday returns the integer number representing the hour number of the given date.
Exercise: EXTRACT hourofday from the pickup_datetime feature.
Create a model titled "model_2"
EXTRACT the hourofday from the pickup_datetime feature to improve our model's rmse.
End of explanation
# TODO: Your code goes here
# TODO: Your code goes here
%%bigquery
#SOLUTION
SELECT * FROM ML.EVALUATE(MODEL feat_eng.model_2)
%%bigquery
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.model_2)
Explanation: Exercise: Create two SQL statements to evaluate the model.
End of explanation
# TODO: Your code goes here
%%bigquery
#SOLUTION
CREATE OR REPLACE MODEL feat_eng.revised_model_3
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
#pickup_datetime,
#EXTRACT(DAYOFWEEK FROM pickup_datetime) AS dayofweek,
#EXTRACT(HOUR FROM pickup_datetime) AS hourofday,
CONCAT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING),
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING)) AS hourofday,
pickuplon,
pickuplat,
dropofflon,
dropofflat
FROM `feat_eng.feateng_training_data`
Explanation: Model 3: Feature cross dayofweek and hourofday
First, let’s allow the model to learn traffic patterns by creating a new feature that combines the time of day and day of week (this is called a feature cross).
Modify model_2 to create a feature cross that combines the time of day and day of week. Note: CAST DAYOFWEEK and HOUR as strings. Name the model "model_3".
In this lab, we will modify the SQL to first use the CONCAT function to concatenate (feature cross) the dayofweek and hourofday features. Then, we will use the ML.FEATURE_CROSS, BigQuery's new pre-processing feature cross function.
Note: BQML by default assumes that numbers are numeric features, and strings are categorical features. We need to convert these features to strings because the Neural Network will treat 1,2,3,4,5,6,7 as numeric values. Thus, there is no way to distinguish the time of day and day of week "numerically."
Exercise: Create the SQL statement to feature cross the dayofweek and hourofday using the CONCAT function.
End of explanation
%%bigquery
#SOLUTION
SELECT * FROM ML.EVALUATE(MODEL feat_eng.model_3)
%%bigquery
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.model_3)
Explanation: Exercise: Create two SQL statements to evaluate the model.
End of explanation
%%bigquery
CREATE OR REPLACE MODEL feat_eng.model_4
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
#pickup_datetime,
#EXTRACT(DAYOFWEEK FROM pickup_datetime) AS dayofweek,
#EXTRACT(HOUR FROM pickup_datetime) AS hourofday,
#CONCAT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING),
#CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING)) AS hourofday,
ML.FEATURE_CROSS(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING),
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING) AS hourofday)) AS day_hr,
pickuplon,
pickuplat,
dropofflon,
dropofflat
FROM `feat_eng.feateng_training_data`
%%bigquery
#SOLUTION
CREATE OR REPLACE MODEL feat_eng.model_4
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
#pickup_datetime,
#EXTRACT(DAYOFWEEK FROM pickup_datetime) AS dayofweek,
#EXTRACT(HOUR FROM pickup_datetime) AS hourofday,
#CONCAT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING),
#CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING)) AS hourofday,
ML.FEATURE_CROSS(STRUCT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING) AS dayofweek,
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING) AS hourofday)) AS day_hr,
pickuplon,
pickuplat,
dropofflon,
dropofflat
FROM `feat_eng.feateng_training_data`
Explanation: Model 4: Apply the ML.FEATURE_CROSS clause to categorical features
BigQuery ML now has ML.FEATURE_CROSS, a pre-processing function that performs a feature cross.
ML.FEATURE_CROSS generates a STRUCT feature with all combinations of crossed categorical features, except for 1-degree items (the original features) and self-crossing items.
Syntax: ML.FEATURE_CROSS(STRUCT(features), degree)
The feature parameter is a categorical features separated by comma to be crossed. The maximum number of input features is 10. Unnamed feature is not allowed in features. Duplicates are not allowed in features.
Degree(optional): The highest degree of all combinations. Degree should be in the range of [1, 4]. Default to 2.
Output: The function outputs a STRUCT of all combinations except for 1-degree items (the original features) and self-crossing items, with field names as concatenation of original feature names and values as the concatenation of the column string values.
Exercise: The ML.Feature_Cross statement contains errors. Correct the errors and run the query.
End of explanation
%%bigquery
SELECT * FROM ML.EVALUATE(MODEL feat_eng.model_4)
%%bigquery
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.model_4)
Explanation: Exercise: Create two SQL statements to evaluate the model.
End of explanation
# TODO
%%bigquery
#Solution
CREATE OR REPLACE MODEL feat_eng.model_5
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
#pickup_datetime,
#EXTRACT(DAYOFWEEK FROM pickup_datetime) AS dayofweek,
#EXTRACT(HOUR FROM pickup_datetime) AS hourofday,
#CONCAT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING),
#CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING)) AS hourofday,
ML.FEATURE_CROSS(STRUCT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING) AS dayofweek,
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING) AS hourofday)) AS day_hr,
#pickuplon,
#pickuplat,
#dropofflon,
#dropofflat,
ST_Distance(ST_GeogPoint(pickuplon, pickuplat), ST_GeogPoint(dropofflon, dropofflat))
AS euclidean
FROM `feat_eng.feateng_training_data`
Explanation: LAB 02: Applying Feature Engineering to BigQuery ML Models
Learning Objectives
Derive coordinate features
Feature cross coordinate features
Evalute model performance
Code cleanup
Introduction
In this notebook, we derive coordinate features, feature cross coordinate features, evaluate model performance, and cleanup the code.
Model 5: Feature cross coordinate features to create a Euclidean feature
Pickup coordinate:
* pickup_longitude AS pickuplon
* pickup_latitude AS pickuplat
Dropoff coordinate:
* #dropoff_longitude AS dropofflon
* #dropoff_latitude AS dropofflat
NOTES:
* The pick-up and drop-off longitude and latitude data are crucial to predicting the fare amount as fare amounts in NYC taxis are largely determined by the distance traveled. Assuch, we need to teach the model the Euclidean distance between the pick-up and drop-off points.
Recall that latitude and longitude allows us to specify any location on Earth using a set of coordinates. In our training data set, we restricted our data points to only pickups and drop offs within NYC. NYC has an approximate longitude range of -74.05 to -73.75 and a latitude range of 40.63 to 40.85.
The dataset contains information regarding the pickup and drop off coordinates. However, there is no information regarding the distance between the pickup and drop off points. Therefore, we create a new feature that calculates the distance between each pair of pickup and drop off points. We can do this using the Euclidean Distance, which is the straight-line distance between any two coordiante points.
We need to convert those coordinates into a single column of a spatial data type. We will use the The ST_Distance function, which returns the minimum distance between two spatial objects.
Exercise: Derive a coordinate feature.
Convert the feature coordinates into a single column of a spatial data type. Use the The ST_Distance function, which returns the minimum distance between two spatial objects.
SAMPLE CODE:
ST_Distance(ST_GeogPoint(value1,value2), ST_GeogPoint(value3, value4)) AS euclidean
End of explanation
# TODO: Your code goes here
%%bigquery
SELECT * FROM ML.EVALUATE(MODEL feat_eng.model_5)
%%bigquery
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.model_5)
Explanation: Exercise: Create two SQL statements to evaluate the model.
End of explanation
%%bigquery
#TODO
CREATE OR REPLACE MODEL feat_eng.model_6
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
#pickup_datetime,
#EXTRACT(DAYOFWEEK FROM pickup_datetime) AS dayofweek,
#EXTRACT(HOUR FROM pickup_datetime) AS hourofday,
#CONCAT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING),
#CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING)) AS hourofday,
ML.FEATURE_CROSS(STRUCT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING) AS dayofweek,
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING) AS hourofday)) AS day_hr,
#pickuplon,
#pickuplat,
#dropofflon,
#dropofflat,
ST_AsText(ST_SnapToGrid(ST_GeogPoint(pickuplat,pickuplon,pickuplat), 0.05)),
ST_AsText(ST_GeogPoint(dropofflon, dropofflat,dropofflon), 0.04)) AS pickup_and_dropoff
FROM `feat_eng.feateng_training_data`
%%bigquery
#SOLUTION
CREATE OR REPLACE MODEL feat_eng.model_6
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
#pickup_datetime,
#EXTRACT(DAYOFWEEK FROM pickup_datetime) AS dayofweek,
#EXTRACT(HOUR FROM pickup_datetime) AS hourofday,
ML.FEATURE_CROSS(STRUCT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING) AS dayofweek,
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING) AS hourofday)) AS day_hr,
#pickuplon,
#pickuplat,
#dropofflon,
#dropofflat,
ST_Distance(ST_GeogPoint(pickuplon, pickuplat), ST_GeogPoint(dropofflon, dropofflat))
AS euclidean,
CONCAT(ST_AsText(ST_SnapToGrid(ST_GeogPoint(pickuplon, pickuplat), 0.01)),
ST_AsText(ST_SnapToGrid(ST_GeogPoint(dropofflon, dropofflat), 0.01)))
AS pickup_and_dropoff
FROM `feat_eng.feateng_training_data`
Explanation: Model 6: Feature cross pick-up and drop-off locations features
In this section, we feature cross the pick-up and drop-off locations so that the model can learn pick-up-drop-off pairs that will require tolls.
This step takes the geographic point corresponding to the pickup point and grids to a 0.1-degree-latitude/longitude grid (approximately 8km x 11km in New York—we should experiment with finer resolution grids as well). Then, it concatenates the pickup and dropoff grid points to learn “corrections” beyond the Euclidean distance associated with pairs of pickup and dropoff locations.
Because the lat and lon by themselves don't have meaning, but only in conjunction, it may be useful to treat the fields as a pair instead of just using them as numeric values. However, lat and lon are continuous numbers, so we have to discretize them first. That's what SnapToGrid does.
REMINDER: The ST_GEOGPOINT creates a GEOGRAPHY with a single point. ST_GEOGPOINT creates a point from the specified FLOAT64 longitude and latitude parameters and returns that point in a GEOGRAPHY value. The ST_Distance function returns the minimum distance between two spatial objectsa. It also returns meters for geographies and SRID units for geometrics.
Excercise: The following SQL statement is incorrect. Modify the code to feature cross the pick-up and drop-off locations features.
End of explanation
%%bigquery
#SOLUTION
SELECT * FROM ML.EVALUATE(MODEL feat_eng.model_6)
%%bigquery
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.model_6)
Explanation: Exercise: Create two SQL statements to evaluate the model.
End of explanation
%%bigquery
#Solution
CREATE OR REPLACE MODEL feat_eng.model_6
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
ML.FEATURE_CROSS(STRUCT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING) AS dayofweek,
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING) AS hourofday)) AS day_hr,
ST_Distance(ST_GeogPoint(pickuplon, pickuplat), ST_GeogPoint(dropofflon, dropofflat))
AS euclidean,
CONCAT(ST_AsText(ST_SnapToGrid(ST_GeogPoint(pickuplon, pickuplat), 0.01)),
ST_AsText(ST_SnapToGrid(ST_GeogPoint(dropofflon, dropofflat), 0.01)))
AS pickup_and_dropoff
FROM `feat_eng.feateng_training_data`
Explanation: Code Clean Up
Exercise: Clean up the code to see where we are
Remove all the commented statements in the SQL statement. We should now have a total of five input features for our model.
1. fare_amount
2. passengers
3. day_hr
4. euclidean
5. pickup_and_dropoff
End of explanation
#TODO
%%bigquery
#SOLUTION
CREATE OR REPLACE MODEL feat_eng.model_7
OPTIONS
(model_type='linear_reg',
input_label_cols=['fare_amount'])
AS
SELECT
fare_amount,
passengers,
SQRT( (pickuplon-dropofflon)*(pickuplon-dropofflon) + (pickuplat-dropofflat)*(pickuplat-dropofflat) ) AS euclidean,
ML.FEATURE_CROSS(STRUCT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING) AS dayofweek,
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING) AS hourofday)) AS day_hr,
CONCAT(
ML.BUCKETIZE(pickuplon, GENERATE_ARRAY(-78, -70, 0.01)),
ML.BUCKETIZE(pickuplat, GENERATE_ARRAY(37, 45, 0.01)),
ML.BUCKETIZE(dropofflon, GENERATE_ARRAY(-78, -70, 0.01)),
ML.BUCKETIZE(dropofflat, GENERATE_ARRAY(37, 45, 0.01))
) AS pickup_and_dropoff
FROM `feat_eng.feateng_training_data`
Explanation: LAB 03: Applying Feature Engineering to BigQuery ML Models
Learning Objectives
Apply the BUCKETIZE function
Apply the TRANSFORM clause
Apply L2 Regularization
Model evaluation
Introduction
In this notebook, we apply the BUCKETIZE function, the TRANSFORM clause, L2 Regularization, and perform model evaluation.
BQML's Pre-processing functions:
Here are some of the preprocessing functions in BigQuery ML:
* ML.FEATURE_CROSS(STRUCT(features)) does a feature cross of all the combinations
* ML.POLYNOMIAL_EXPAND(STRUCT(features), degree) creates x, x^2, x^3, etc.
* ML.BUCKETIZE(f, split_points) where split_points is an array
Model 7: Apply the BUCKETIZE Function
BUCKETIZE
Bucketize is a pre-processing function that creates "buckets" (e.g bins) - e.g. it bucketizes a continuous numerical feature into a string feature with bucket names as the value.
ML.BUCKETIZE(feature, split_points)
feature: A numerical column.
split_points: Array of numerical points to split the continuous values in feature into buckets. With n split points (s1, s2 … sn), there will be n+1 buckets generated.
Output: The function outputs a STRING for each row, which is the bucket name. bucket_name is in the format of bin_<bucket_number>, where bucket_number starts from 1.
Currently, our model uses the ST_GeogPoint function to derive the pickup and dropoff feature. In this lab, we use the BUCKETIZE function to create the pickup and dropoff feature.
Exercise: Apply the BUCKETIZE function.
Hint: Create a model_7.
End of explanation
%%bigquery
SELECT *, SQRT(loss) AS rmse FROM ML.TRAINING_INFO(MODEL feat_eng.model_7)
%%bigquery
SELECT * FROM ML.EVALUATE(MODEL feat_eng.model_7)
%%bigquery
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.model_7)
Explanation: Exercise: Create three SQL statements to EVALUATE the model.
End of explanation
#TODO
%%bigquery
#SOLUTION
CREATE OR REPLACE MODEL feat_eng.final_model
TRANSFORM(
fare_amount,
SQRT( (pickuplon-dropofflon)*(pickuplon-dropofflon) + (pickuplat-dropofflat)*(pickuplat-dropofflat) ) AS euclidean,
ML.FEATURE_CROSS(STRUCT(CAST(EXTRACT(DAYOFWEEK FROM pickup_datetime) AS STRING) AS dayofweek,
CAST(EXTRACT(HOUR FROM pickup_datetime) AS STRING) AS hourofday)) AS day_hr,
CONCAT(
ML.BUCKETIZE(pickuplon, GENERATE_ARRAY(-78, -70, 0.01)),
ML.BUCKETIZE(pickuplat, GENERATE_ARRAY(37, 45, 0.01)),
ML.BUCKETIZE(dropofflon, GENERATE_ARRAY(-78, -70, 0.01)),
ML.BUCKETIZE(dropofflat, GENERATE_ARRAY(37, 45, 0.01))
) AS pickup_and_dropoff
)
OPTIONS(input_label_cols=['fare_amount'], model_type='linear_reg', l2_reg=0.1)
AS
SELECT * FROM feat_eng.feateng_training_data
Explanation: Final Model: Apply the TRANSFORM clause and L2 Regularization
Before we perform our prediction, we should encapsulate the entire feature set in a TRANSFORM clause. BigQuery ML now supports defining data transformations during model creation, which will be automatically applied during prediction and evaluation. This is done through the TRANSFORM clause in the existing CREATE MODEL statement. By using the TRANSFORM clause, user specified transforms during training will be automatically applied during model serving (prediction, evaluation, etc.)
In our case, we are using the TRANSFORM clause to separate out the raw input data from the TRANSFORMED features. The input columns of the TRANSFORM clause is the query_expr (AS SELECT part). The output columns of TRANSFORM from select_list are used in training. These transformed columns are post-processed with standardization for numerics and one-hot encoding for categorical variables by default.
The advantage of encapsulating features in the TRANSFORM is the client code doing the PREDICT doesn't change. Our model improvement is transparent to client code. Note that the TRANSFORM clause MUST be placed after the CREATE statement.
L2 Regularization
Sometimes, the training RMSE is quite reasonable, but the evaluation RMSE illustrate more error. Given the severity of the delta between the EVALUATION RMSE and the TRAINING RMSE, it may be an indication of overfitting. When we do feature crosses, we run into the risk of overfitting (for example, when a particular day-hour combo doesn't have enough taxirides).
Exercise: Apply the TRANSFORM clause and L2 Regularization to the final model and run the query.
End of explanation
%%bigquery
SELECT *, SQRT(loss) AS rmse FROM ML.TRAINING_INFO(MODEL feat_eng.final_model)
%%bigquery
SELECT * FROM ML.EVALUATE(MODEL feat_eng.final_model)
%%bigquery
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.final_model)
Explanation: Exercise: Create three SQL statements to EVALUATE the final model.
End of explanation
%%bigquery
#TODO
SELECT * FROM ML.EVALUATE(MODEL feat_eng.benchmark_model, (
-73.982683 AS pickuplon,
40.742104 AS pickuplat,
-73.983766 AS dropofflon,
40.755174 AS dropofflat,
3.0 AS passengers,
TIMESTAMP('2019-06-03 04:21:29.769443 UTC) AS pickup_datetime
))
%%bigquery
#SOLUTION
# This is the prediction query FOR heading 1.3 miles uptown in New York City on 2019-06-03 at 04:21:29.769443 UTC time with 3 passengers.
SELECT * FROM ML.PREDICT(MODEL feat_eng.final_model, (
SELECT
-73.982683 AS pickuplon,
40.742104 AS pickuplat,
-73.983766 AS dropofflon,
40.755174 AS dropofflat,
3.0 AS passengers,
TIMESTAMP('2019-06-03 04:21:29.769443 UTC') AS pickup_datetime
))
Explanation: LAB 04: Applying Feature Engineering to BigQuery ML ModelS
Learning Objectives
Create a prediction model
Evalute model performance
Examine the role of feature engineering on the ML problem
Introduction
In this notebook, we create prediction models, evaluate model performance, and examine the role of feature engineering on the ML problem.
Prediction Model
Now that you have evaluated your model, the next step is to use it to predict an outcome. You use your model to predict the taxifare amount.
The ML.PREDICT function is used to predict results using your model: feat_eng.final_model.
Since this is a regression model (predicting a continuous numerical value), the best way to see how it performed is to evaluate the difference between the value predicted by the model and the benchmark score. We can do this with an ML.PREDICT query.
Exercise: Modify THIS INCORRECT SQL STRATEMENT before running the query.
End of explanation
#TODO
%%bigquery
#SOLUTION - remove passengers
SELECT * FROM ML.PREDICT(MODEL feat_eng.final_model, (
SELECT
-73.982683 AS pickuplon,
40.742104 AS pickuplat,
-73.983766 AS dropofflon,
40.755174 AS dropofflat,
TIMESTAMP('2019-06-03 04:21:29.769443 UTC') AS pickup_datetime
))
Explanation: Exercise: Remove passengers from the prediction model.
End of explanation
import matplotlib.pyplot as plt; plt.rcdefaults()
import numpy as np
import matplotlib.pyplot as plt
models = ('bench','m1', 'm2', 'm3', 'm4', 'm5', 'm6','m7', 'final')
y_pos = np.arange(len(models))
rmse = [8.29,9.431,8.408,9.657,9.657,5.588,5.906,5.759,4.653]
plt.bar(y_pos, rmse, align='center', alpha=0.5)
plt.xticks(y_pos, models)
plt.ylabel('RMSE')
plt.title('RMSE Model Summary')
plt.show()
import matplotlib.pyplot as plt
%matplotlib inline
plt.style.use('ggplot')
x = ['bench','m1', 'm2', 'm3', 'm4', 'm5', 'm6','m7', 'final']
RMSE = [8.29,9.431,8.408,9.657,9.657,5.588,5.906,5.759,4.653]
x_pos = [i for i, _ in enumerate(x)]
plt.bar(x_pos, RMSE, color='green')
plt.xlabel("Model")
plt.ylabel("RMSE")
plt.title("RMSE Model Summary")
plt.xticks(x_pos, x)
plt.show()
%%bigquery
CREATE OR REPLACE MODEL feat_eng.challenge_model
TRANSFORM(fare_amount,
SQRT( (pickuplon-dropofflon)*(pickuplon-dropofflon) + (pickuplat-dropofflat)*(pickuplat-dropofflat) ) AS euclidean,
IF(EXTRACT(dayofweek FROM pickup_datetime) BETWEEN 2 and 6, 'weekday', 'weekend') AS dayofweek,
ML.BUCKETIZE(EXTRACT(HOUR FROM pickup_datetime), [5, 10, 17]) AS day_hr,
CONCAT(
ML.BUCKETIZE(pickuplon, GENERATE_ARRAY(-78, -70, 0.01)),
ML.BUCKETIZE(pickuplat, GENERATE_ARRAY(37, 45, 0.01)),
ML.BUCKETIZE(dropofflon, GENERATE_ARRAY(-78, -70, 0.01)),
ML.BUCKETIZE(dropofflat, GENERATE_ARRAY(37, 45, 0.01))
) AS pickup_and_dropoff
)
OPTIONS(input_label_cols=['fare_amount'], model_type='linear_reg', l2_reg=0.1)
AS
SELECT
*
FROM `feat_eng.feateng_training_data`
Explanation: What can you conclude when the feature passengers is removed from the prediction model?
ANSWER: Number of passengers at this pickup_datetime and location does not affect fare.
Lab Summary:
Our ML problem: Develop a model to predict taxi fare based on distance -- from one point to another in New York City.
Using feature engineering, we were able to predict a taxi fare of $6.08 in New York City, with an R2 score of .75, and an RMSE of 4.653 based upon the distance travelled.
Exercise: Create a RMSE summary table.
Markdown table generator: http://www.tablesgenerator.com/markdown_tables
Create a RMSE summary table:
| Model | RMSE | Description |
|-----------------|-------|---------------------------------------------------------------------------------|
| benchmark_model | 8.29 | --Benchmark model - no feature engineering |
| model_1 | 9.431 | --EXTRACT DayOfWeek from the pickup_datetime feature |
| model_2 | 8.408 | --EXTRACT hourofday from the pickup_datetime feature |
| model_3 | 9.657 | --Feature cross dayofweek and hourofday -Feature Cross does lead ot overfitting |
| model_4 | 9.657 | --Apply the ML.FEATURE_CROSS clause to categorical features |
| model_5 | 5.588 | --Feature cross coordinate features to create a Euclidean feature |
| model_6 | 5.906 | --Feature cross pick-up and drop-off locations features |
| model_7 | 5.75 | --Apply the BUCKETIZE function |
| final_model | 4.653 | --Apply the TRANSFORM clause and L2 Regularization |
Excercise: Visualization - Plot a bar chart.
End of explanation
%%bigquery
SELECT *, SQRT(loss) AS rmse FROM ML.TRAINING_INFO(MODEL feat_eng.challenge_model)
%%bigquery
SELECT * FROM ML.EVALUATE(MODEL feat_eng.challenge_model)
%%bigquery
SELECT SQRT(mean_squared_error) AS rmse FROM ML.EVALUATE(MODEL feat_eng.challenge_model)
%%bigquery
#PREDICTION on the CHALLENGE MODEL
#In this model, we do not show a pickup time because the bucketize has put pickup time in three buckets:
#5,10,17
#How do we not show pickup datetime?
SELECT * FROM ML.PREDICT(MODEL feat_eng.challenge_model, (
SELECT
-73.982683 AS pickuplon,
40.742104 AS pickuplat,
-73.983766 AS dropofflon,
40.755174 AS dropofflat,
TIMESTAMP('2019-06-03 04:21:29.769443 UTC') AS pickup_datetime
))
Explanation: Exercise: Create three SQL statements to EVALUATE the challenge model.
End of explanation |
3,410 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Spectrally-resolved Outgoing Longwave Radiation (OLR) with RRTMG_LW
In this notebook we will demonstrate how to use climlab.radiation.RRTMG_LW to investigate the clear-sky, longwave response of the atmosphere to perturbations in $CO_{2}$ and SST. In particular, we will use the new return_spectral_olr feature to explain the behaviour of the OLR to these changes.
Originally contributed by Andrew Williams
Step2: Set up idealized atmospheric profiles of temperature and humidity
In this example, we will use a temperature profile which is a moist adiabat, pegged to an isothermal stratosphere at $T_{strat}=200 \mathrm{K}$. We will also assume that relative humidity is fixed (a decent first-order assumption) at a constant value of $\mathrm{RH}=0.8$, with a profile given by climlab.radiation.water_vapor.ManabeWaterVapor.
Step3: Now, compute specific humidity profile using climlab.radiation.water_vapor.ManabeWaterVapor
Step4: Run the profiles through RRTMG_LW
With $CO_{2}=280\mathrm{ppmv}$ and all other radiatively active gases (aside from water vapour) set to zero.
Step5: Now, wrap it all into a simple function
This will make it easier to explore the behaviour of the OLR as a function of temperature and $CO_{2}$.
Step6: Now, lets iterate over a few (SST, CO2) pairs
Step7: Okay then! As expected we can see that, all else being equal, increasing CO$_{2}$ <span style="color
Step9: Now, lets check to see if we get the familiar Planck curve
Step10: Now, what happens when we include $CO_{2}$?
Step11: As we saw before, including $CO_{2}$ in the radiative transfer calculation reduces the total OLR (i.e., the spectral integral over what we've plotted). This happens predominantly due to absorption at the center of the $15 \mu\mathrm{m}$ $CO_{2}$ band (around $667.5 \mathrm{cm}^{-1}$).
Note that increasing the $CO_{2}$ concentration causes a greater reduction at the center of the band, with increasing absorption at the edges (commonly referred to as the 'wings') of the band.
What about water vapour?
Now, we'll redo the calculation, but include the specific humidity of water vapour in the call to RRTMG_LW.
Step13: Water vapour clearly also influences the OLR spectrum quite a bit! Two interesting things to note
Step14: Nice!
We can clearly see from this plot that the OLR in the water vapour windows saturates between 300K and 320K
To make this more quantitative, lets consider the 'spectral' feedback parameter $\lambda_{\nu}$ for each SST, which is defined as the change in OLR per degree of warming, which we calculate as
Step16: At low temperatures, the feedback parameter in the window region is close the the Planck feedback, indicating efficient emission to space from these wavenumbers.
Step19: At higher temperatures, water vapour becomes optically thick in the window region, causing the OLR to become less sensitive to changes in surface temperature. As such, the feedback parameter reduces rapidly. | Python Code:
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
import climlab
import xarray as xr
import scipy.integrate as sp #Gives access to the ODE integration package
Explanation: Spectrally-resolved Outgoing Longwave Radiation (OLR) with RRTMG_LW
In this notebook we will demonstrate how to use climlab.radiation.RRTMG_LW to investigate the clear-sky, longwave response of the atmosphere to perturbations in $CO_{2}$ and SST. In particular, we will use the new return_spectral_olr feature to explain the behaviour of the OLR to these changes.
Originally contributed by Andrew Williams
End of explanation
from climlab.utils.thermo import pseudoadiabat
def generate_idealized_temp_profile(SST, plevs, Tstrat=200):
Generates an idealized temperature profile with specified SST and Tstrat
solution = sp.odeint(pseudoadiabat, SST, np.flip(plevs))
temp = solution.reshape(-1)
temp[np.where(temp<Tstrat)] = Tstrat
return np.flip(temp) # need to re-invert the pressure axis
def make_idealized_column(SST, num_lev=100, Tstrat=200):
# Set up a column state
state = climlab.column_state(num_lev=num_lev, num_lat=1)
# Extract the pressure levels
plevs = state['Tatm'].domain.axes['lev'].points
# Set the SST
state['Ts'][:] = SST
# Set the atmospheric profile to be our idealized profile
state['Tatm'][:] = generate_idealized_temp_profile(SST=SST, plevs=plevs, Tstrat=Tstrat)
return state
state = make_idealized_column(300)
# Plot the profile
fig, ax = plt.subplots(dpi=100)
state['Tatm'].to_xarray().plot(ax=ax, y='lev', yincrease=False)
ax.set_xlabel("Temperature (K)")
ax.set_ylabel("Pressure (hPa)")
ax.grid()
Explanation: Set up idealized atmospheric profiles of temperature and humidity
In this example, we will use a temperature profile which is a moist adiabat, pegged to an isothermal stratosphere at $T_{strat}=200 \mathrm{K}$. We will also assume that relative humidity is fixed (a decent first-order assumption) at a constant value of $\mathrm{RH}=0.8$, with a profile given by climlab.radiation.water_vapor.ManabeWaterVapor.
End of explanation
h2o = climlab.radiation.water_vapor.ManabeWaterVapor(state=state,
relative_humidity=0.8)
fig, ax = plt.subplots(dpi=100)
h2o.q.to_xarray().plot(ax=ax, y='lev', yincrease=False)
ax.set_xlabel("Specific humidity (g/g)")
ax.set_ylabel("Pressure (hPa)")
ax.grid()
Explanation: Now, compute specific humidity profile using climlab.radiation.water_vapor.ManabeWaterVapor
End of explanation
absorber_vmr = {'CO2':280/1e6,
'CH4':0.,
'N2O':0.,
'O2':0.,
'CFC11':0.,
'CFC12':0.,
'CFC22':0.,
'CCL4':0.,
'O3':0.}
# RRTMG radiation
rad = climlab.radiation.RRTMG_LW(state=state, specific_humidity=h2o.q,
icld=0, # Clear-sky only!
return_spectral_olr=False, # Just return total OLR
absorber_vmr = absorber_vmr)
rad.compute_diagnostics()
rad.OLR
Explanation: Run the profiles through RRTMG_LW
With $CO_{2}=280\mathrm{ppmv}$ and all other radiatively active gases (aside from water vapour) set to zero.
End of explanation
def calc_olr(SST, CO2ppmv, return_spectral_olr=False, RH=0.8, Tstrat=200, qStrat=5e-06):
# Couple water vapor to radiation
## climlab setup
# create surface and atmosperic domains
state = make_idealized_column(SST, Tstrat=Tstrat)
# fixed relative humidity
# Note we pass the qStrat parameter here, which sets a minimum specific humidity
# Set RH=0. and qStrat=0. for fully dry column
h2o = climlab.radiation.water_vapor.ManabeWaterVapor(state=state,
relative_humidity=RH,
qStrat=qStrat,
)
absorber_vmr['CO2'] = CO2ppmv/1e6
# RRTMG radiation
rad = climlab.radiation.rrtm.rrtmg_lw.RRTMG_LW(state=state, specific_humidity=h2o.q,
icld=0, # Clear-sky only!
return_spectral_olr=return_spectral_olr,
absorber_vmr = absorber_vmr)
rad.compute_diagnostics()
return rad
# Test this gives the same as before...
calc_olr(SST=300, CO2ppmv=280).OLR
Explanation: Now, wrap it all into a simple function
This will make it easier to explore the behaviour of the OLR as a function of temperature and $CO_{2}$.
End of explanation
%%time
n=20
OLRS = np.zeros((n,n))
temparray = np.linspace(280, 290, n)
co2array = np.linspace(280, 1200, n)
for idx1, temp in enumerate(temparray):
for idx2, co2 in enumerate(co2array):
OLRS[idx1, idx2] = calc_olr(temp, co2).OLR
da = xr.DataArray(OLRS, dims=['temp', 'co2'],
coords={'temp':temparray,
'co2':co2array},
)
fig, ax = plt.subplots(dpi=100)
p = da.plot.contourf(ax=ax,
cmap='viridis',
levels=20,
add_colorbar=False)
fig.colorbar(p, label="OLR (W m$^{-2}$)")
ax.set_xlabel("$CO_{2}$ (ppmv)")
ax.set_ylabel("SST (K)")
Explanation: Now, lets iterate over a few (SST, CO2) pairs
End of explanation
# To do this, we'll run the model with the idealized temperature profile
# but not include the effects of water vapour (i.e., set RH=0 and qStrat=0)
# We've already set all other absorbing species to 0.
rad1 = calc_olr(SST=300, CO2ppmv=0., RH=0., return_spectral_olr=True, qStrat=0.)
# check that the different OLRs match up...
print(rad1.OLR_spectral.to_xarray().sum('wavenumber').values)
print(rad1.OLR)
Explanation: Okay then! As expected we can see that, all else being equal, increasing CO$_{2}$ <span style="color:blue">decreases the OLR</span>, whereas increasing the SST <span style="color:red">increases the OLR</span> in the model.
So then, what do these changes look like in wavenumber space? We can investigate this using the new return_spectral_olr argument to RRTMG_LW!
First though, let's check the model reproduces the Planck curve!
End of explanation
wavenumbers = np.linspace(0.1, 3000) # don't start from zero to avoid divide by zero warnings
# Centers and Widths of the spectral bands, cm-1
spectral_centers = rad1.OLR_spectral.domain.axes['wavenumber'].points
spectral_widths = rad1.OLR_spectral.domain.axes['wavenumber'].delta
def planck_curve(wavenumber, T):
'''Return the Planck curve in units of W/m2/cm-1
Inputs: wavenumber in cm-1
temperature T in units of K'''
# 100pi factor converts from steradians/m to 1/cm
return (climlab.utils.thermo.Planck_wavenumber(wavenumber, T)*100*np.pi)
def make_planck_curve(ax, T, color='orange'):
'''Plot the Planck curve (W/m2/cm-1) on the given ax object'''
ax.plot(wavenumbers, planck_curve(wavenumbers, T),
lw=2, color=color, label="Planck curve, {}K".format(T))
def make_planck_feedback(ax, T, color='orange'):
'''Plot the Planck spectral feedback parameter (mW/m2/cm-1/K) on the given ax object'''
ax.plot(wavenumbers, (planck_curve(wavenumbers, T+1)-planck_curve(wavenumbers, T))*1000,
lw=2, color=color, label="Planck feedback, {}K".format(T))
def make_rrtmg_spectrum(ax, OLR_spectral, color='blue', alpha=0.5, label='RRTMG - 300K'):
# Need to normalize RRTMG spectral outputs by width of each wavenumber band
ax.bar(spectral_centers, np.squeeze(OLR_spectral)/spectral_widths,
width=spectral_widths, color=color, edgecolor='black', alpha=alpha, label=label)
Plot !
fig, ax = plt.subplots(dpi=100)
make_planck_curve(ax, 300, color='orange')
make_rrtmg_spectrum(ax, rad1.OLR_spectral, label='RRTMG - 300K')
ax.legend(frameon=False)
ax.set_xlabel("Wavenumber (cm$^{-1}$)")
ax.set_ylabel("TOA flux (W/m$^{2}$/cm$^{-1}$)")
ax.grid()
Explanation: Now, lets check to see if we get the familiar Planck curve
End of explanation
# Same calculation as above but with some well-mixed CO2 in the column
rad2 = calc_olr(SST=300, CO2ppmv=10, RH=0., qStrat=0., return_spectral_olr=True, )
rad3 = calc_olr(SST=300, CO2ppmv=280, RH=0., qStrat=0., return_spectral_olr=True, )
fig, ax = plt.subplots(dpi=100)
make_planck_curve(ax, 300, color='orange')
make_rrtmg_spectrum(ax, rad1.OLR_spectral, label='RRTMG - 300K, 0ppmv CO2', color='blue')
make_rrtmg_spectrum(ax, rad2.OLR_spectral, label='RRTMG - 300K, 10ppmv CO2', color='orange')
make_rrtmg_spectrum(ax, rad3.OLR_spectral, label='RRTMG - 300K, 280ppmv CO2', color='green')
ax.legend(frameon=False)
ax.set_xlabel("Wavenumber (cm$^{-1}$)")
ax.set_ylabel("TOA flux (W/m$^{2}$/cm$^{-1}$)")
ax.grid()
Explanation: Now, what happens when we include $CO_{2}$?
End of explanation
# Our calc_olr() function handles water vapor by setting the RH parameter
rad4 = calc_olr(SST=300, CO2ppmv=0., RH=0.8, return_spectral_olr=True, )
fig, ax = plt.subplots(dpi=100, figsize=(7,4))
make_planck_curve(ax, 300, color='orange')
make_rrtmg_spectrum(ax, rad1.OLR_spectral, label="RRTMG - 300K, 0ppmv CO2", color='blue')
make_rrtmg_spectrum(ax, rad4.OLR_spectral, label="RRTMG - 300K, water vapour, 0ppmv CO2", color='orange')
ax.legend(frameon=False, loc='upper right')
ax.set_xlabel("Wavenumber (cm$^{-1}$)")
ax.set_ylabel("TOA flux (W/m$^{2}$/cm$^{-1}$)")
ax.grid()
Explanation: As we saw before, including $CO_{2}$ in the radiative transfer calculation reduces the total OLR (i.e., the spectral integral over what we've plotted). This happens predominantly due to absorption at the center of the $15 \mu\mathrm{m}$ $CO_{2}$ band (around $667.5 \mathrm{cm}^{-1}$).
Note that increasing the $CO_{2}$ concentration causes a greater reduction at the center of the band, with increasing absorption at the edges (commonly referred to as the 'wings') of the band.
What about water vapour?
Now, we'll redo the calculation, but include the specific humidity of water vapour in the call to RRTMG_LW.
End of explanation
SSTcolors = {320: 'green',
300: 'orange',
280: 'blue',
}
rad = {}
for SST in SSTcolors:
rad[SST] = calc_olr(SST=SST, CO2ppmv=0., RH=0.8, return_spectral_olr=True, )
Plot !
fig, ax = plt.subplots(dpi=100, figsize=(7,4))
for SST in SSTcolors:
make_planck_curve(ax, SST, color=SSTcolors[SST])
make_rrtmg_spectrum(ax, rad[SST].OLR_spectral,
label="RRTMG - {}K, water vapour, no CO2".format(SST),
color=SSTcolors[SST])
ax.set_xlim(0, 4000)
ax.legend(frameon=False, loc='upper right')
ax.set_xlabel("Wavenumber (cm$^{-1}$)")
ax.set_ylabel("TOA flux (W/m$^{2}$/cm$^{-1}$)")
ax.grid()
Explanation: Water vapour clearly also influences the OLR spectrum quite a bit! Two interesting things to note:
Firstly, water vapour is a strong absorber at a much wider range of wavelengths than $CO_{2}$!
Secondly, there is a region around 800-1500 $\mathrm{cm}^{-1}$, where water vapour doesn't cause much absorption at all! This is the well-known water vapour window, and it is a region where warming can efficiently escape to space from the surface. The behaviour of these window region is extremely important in understanding the temperature dependence of Earth's OLR, and thus climate sensitivity (see, for example, Koll and Cronin (2018)).
$\textit{"Last call for orders! The water vapour window is closing!"}$
Clausius-Clapeyron tells us that the saturation water vapor pressure of water (i.e., the water-holding capacity of the atmosphere) increases by about 6-7% for every 1°C rise in temperature. One important consequence of this is that the optical depth of water vapour increases with temperature, which causes these spectral 'window' regions to eventually become optically thick. When this happens, the OLR in these regions becomes fixed and can't increase with warming. Can we see this in our model?
To do this, we'll run the model again at 280K, 300K and 320K, with a varying water vapour profile. We should see that the OLR in this window region eventually saturates to a constant value.
End of explanation
feedback = {}
for SST in SSTcolors:
# Calculate perturbation (+1K) state diagnostics
rad_p1 = calc_olr(SST=SST+1, CO2ppmv=0., RH=0.8, return_spectral_olr=True, )
# Calculate spectral feedback parameter
feedback[SST] = (rad_p1.OLR_spectral-rad[SST].OLR_spectral)
Explanation: Nice!
We can clearly see from this plot that the OLR in the water vapour windows saturates between 300K and 320K
To make this more quantitative, lets consider the 'spectral' feedback parameter $\lambda_{\nu}$ for each SST, which is defined as the change in OLR per degree of warming, which we calculate as:
$$\lambda_{\nu} = \frac{\mathrm{OLR}{\nu}(\mathrm{SST}+1)- \mathrm{OLR}{\nu}(\mathrm{SST})}{1\mathrm{K}}$$
Hence, because OLR eventually becomes decoupled from the SST at high enough temperatures, we should expect the feedback parameter to rapidly decline (eventually to zero) in these window regions.
End of explanation
Plot !
fig, ax = plt.subplots(dpi=100, figsize=(7,4))
SST=280
make_planck_feedback(ax, SST, color=SSTcolors[SST])
make_rrtmg_spectrum(ax, feedback[SST]*1000,
label="RRTMG - {}K, water vapour, no CO2".format(SST),
color=SSTcolors[SST])
ax.set_xlim(0, 4000)
ax.set_ylim(-0.5, 6)
ax.legend(frameon=False, loc='upper right')
ax.set_xlabel("Wavenumber (cm$^{-1}$)")
ax.set_ylabel(r"$\lambda_{\nu}$ (mW/m$^{2}$/cm$^{-1}/K$)")
ax.grid()
Explanation: At low temperatures, the feedback parameter in the window region is close the the Planck feedback, indicating efficient emission to space from these wavenumbers.
End of explanation
Plot !
fig, ax = plt.subplots(dpi=100, figsize=(7,4))
SST=300
make_planck_feedback(ax, SST, color=SSTcolors[SST])
make_rrtmg_spectrum(ax, feedback[SST]*1000,
label="RRTMG - {}K, water vapour, no CO2".format(SST),
color=SSTcolors[SST])
ax.set_xlim(0, 4000)
ax.set_ylim(-0.5, 6)
ax.legend(frameon=False, loc='upper right')
ax.set_xlabel("Wavenumber (cm$^{-1}$)")
ax.set_ylabel(r"$\lambda_{\nu}$ (mW/m$^{2}$/cm$^{-1}/K$)")
ax.grid()
Plot !
fig, ax = plt.subplots(dpi=100, figsize=(7,4))
SST=320
make_planck_feedback(ax, SST, color=SSTcolors[SST])
make_rrtmg_spectrum(ax, feedback[SST]*1000,
label="RRTMG - {}K, water vapour, no CO2".format(SST),
color=SSTcolors[SST])
ax.set_xlim(0, 4000)
ax.set_ylim(-1, 6.5)
ax.legend(frameon=False, loc='upper right')
ax.set_xlabel("Wavenumber (cm$^{-1}$)")
ax.set_ylabel(r"$\lambda_{\nu}$ (mW/m$^{2}$/cm$^{-1}/K$)")
ax.grid()
Explanation: At higher temperatures, water vapour becomes optically thick in the window region, causing the OLR to become less sensitive to changes in surface temperature. As such, the feedback parameter reduces rapidly.
End of explanation |
3,411 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Using the readings, try and create a RandomForestClassifier for the iris dataset
Step1: Using a 25/75 training/test split, compare the results with the original decision tree model and describe the result to the best of your ability in your PR | Python Code:
iris = datasets.load_iris()
iris.keys()
X = iris.data[:,2:]
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42, test_size=0.25,train_size=0.75)
#What is random_state?
#What is stratify?
#What is this doing in the moon example exactly?
#X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
forest = RandomForestClassifier(n_estimators=5, random_state=100)
forest.fit(X_train, y_train)
print("accuracy on training set: %f" % forest.score(X_train, y_train))
print("accuracy on test set: %f" % forest.score(X_test, y_test))
Explanation: Using the readings, try and create a RandomForestClassifier for the iris dataset
End of explanation
X_train, X_test, y_train, y_test = train_test_split(x,y,test_size=0.25,train_size=0.75)
dt = tree.DecisionTreeClassifier()
dt = dt.fit(X_train,y_train)
y_pred=dt.predict(X_test)
Accuracy_score = metrics.accuracy_score(y_test, y_pred)
Accuracy_score
#Comments on RandomForestClassifiers & Original Decision Tree Model
#While the Random Trees result is consistent, varying depending how you choose the random_state or the n_estimators,
#the result of the orgininal decision tree model varies a lot.
#The random_state defines how random the versions of the data is that the modelling takes into consideration, and
#the n_estimators regulates how many "random" datasets are used. It's fascinating to see how the this makes the
#result so much more consistent than the orginal decision tree model.
#General commets on the homework
#I really enjoyed this homework and it really helped me understand, what is going on under the hood.
#I found this reading while I was doing the homework. It looks nice to go deeper? Do you know the
#guy? https://github.com/amueller/introduction_to_ml_with_python
#I feel I now need practice on real life dirty data sets, to fully understand how predictions models
#can work. I take my comments back, that I can't see how I can implement this into my reporting. I can. But how
#can I do this technically? i.e. with the data on PERM visas? Say input nationality, wage, lawyer, job title, and get a reply what the chances could be of
#getting a work visa? I also feel a little shaky on how I need to prep my data to feed in it into the predictor
#correctly.
#Comments on classifier
#Questions:
#Not sure why it's 10fold cross validation, cv is set at 5?
#Why are we predicting the
Explanation: Using a 25/75 training/test split, compare the results with the original decision tree model and describe the result to the best of your ability in your PR
End of explanation |
3,412 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<center>
<h1> ILI285 - Computación Científica I / INF285 - Computación Científica </h1>
<h2> Finding 2 Chebyshev points graphycally </h2>
<h2> <a href="#acknowledgements"> [S]cientific [C]omputing [T]eam </a> </h2>
<h2> Version
Step1: <div id='cheb' />
Finding 2 Chebyshev points
We compute them so we can compare them later.
Step2: Recall that the Chebyshev points are points that minimize the following expression
Step3: Now we need to evaluate $\omega(x_1,x_2)$ over the domain $\Omega=[0,1]^2$.
Step4: With this data, we can now plot the function $\omega(x_1,x_2)$ on $\Omega$.
The minimun value of is shown by the color at the bottom of the colorbar.
By visual inspection, we see that we have two mins.
They are located at the bottom right and top left.
Step5: Finally, we have included the min in the plot and we see the agreement between the min of $\omega(x_1,x_2)$ and the Chebyshev points found. | Python Code:
import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import matplotlib as mpl
mpl.rcParams['font.size'] = 14
mpl.rcParams['axes.labelsize'] = 20
mpl.rcParams['xtick.labelsize'] = 14
mpl.rcParams['ytick.labelsize'] = 14
%matplotlib inline
Explanation: <center>
<h1> ILI285 - Computación Científica I / INF285 - Computación Científica </h1>
<h2> Finding 2 Chebyshev points graphycally </h2>
<h2> <a href="#acknowledgements"> [S]cientific [C]omputing [T]eam </a> </h2>
<h2> Version: 1.02</h2>
</center>
Table of Contents
Finding 2 Chebyshev points
Python Modules and Functions
Acknowledgements
End of explanation
n=2
i=1
theta1=(2*i-1)*np.pi/(2*n)
i=2
theta2=(2*i-1)*np.pi/(2*n)
c1=np.cos(theta1)
c2=np.cos(theta2)
Explanation: <div id='cheb' />
Finding 2 Chebyshev points
We compute them so we can compare them later.
End of explanation
N=50
x=np.linspace(-1,1,N)
w = lambda x1,x2: np.max(np.abs((x-x1)*(x-x2)))
wv=np.vectorize(w)
Explanation: Recall that the Chebyshev points are points that minimize the following expression:
$$
\displaystyle{\omega(x_1,x_2,\dots,x_n)=\max_{x} |(x-x_1)\,(x-x_2)\,\cdots\,(x-x_n)|}.
$$
This comes from the Interpolation Error Formula (I hope you remember it, otherwise see the textbook or the classnotes!).
In this notebook, we will find the $\min$ for 2 points,
this means:
$$
[x_1,x_2]= \displaystyle{\mathop{\mathrm{argmin}}{x_1,x_2\in [-1,1]}} \,\omega(x_1,x_2)=\displaystyle{\mathop{\mathrm{argmin}}{x_1,x_2\in [-1,1]}}\,
\max_{x\in [-1,1]} |(x-x_1)\,(x-x_2)|.
$$
For doing this, we first need to build $\omega(x_1,x_2)$,
End of explanation
[X,Y]=np.meshgrid(x,x)
W=wv(X,Y)
Explanation: Now we need to evaluate $\omega(x_1,x_2)$ over the domain $\Omega=[0,1]^2$.
End of explanation
plt.figure(figsize=(8,8))
#plt.contourf(X, Y, W,100, cmap=cm.hsv, antialiased=False)
plt.contourf(X, Y, W,100, cmap=cm.nipy_spectral, antialiased=False)
plt.xlabel(r'$x_1$')
plt.ylabel(r'$x_2$')
plt.colorbar()
plt.show()
Explanation: With this data, we can now plot the function $\omega(x_1,x_2)$ on $\Omega$.
The minimun value of is shown by the color at the bottom of the colorbar.
By visual inspection, we see that we have two mins.
They are located at the bottom right and top left.
End of explanation
plt.figure(figsize=(8,8))
plt.contourf(X, Y, W,100, cmap=cm.nipy_spectral, antialiased=False)
plt.plot(c1,c2,'k.',markersize=16)
plt.plot(c2,c1,'k.',markersize=16)
plt.colorbar()
plt.xlabel(r'$x_1$')
plt.ylabel(r'$x_2$')
plt.show()
Explanation: Finally, we have included the min in the plot and we see the agreement between the min of $\omega(x_1,x_2)$ and the Chebyshev points found.
End of explanation |
3,413 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
6. Media experiment design
This notebook demonstrates the design of a media experiment by using the
Experimental Desing
module to activate the predictions from a propensity model. It is vital to design and estimate the impact of media campaigns using valid statistical methods to make sure the limited experimentation budget is utilized effectively and to set the right expectations of the campaign outcome.
Requirements
An already scored test dataset, or the model and the test dataset to be scored available in GCP BigQuery.
This test dataset should contain all the ML instances for at least one snapshot date.
Install and import required modules
Step1: Notebook custom settings
Step2: Set parameters
Step4: Select the relevant data for experiment design
Select all the instances for one snapshot date, which resembles the scoring dataset for one day. This dataset is used to design the media experiment.
Score the test dataset (if not already scored)
Step6: Read the prediction test dataset (if already scored)
Step7: Prepare probability and label columns
Step8: Experiment Design I
Step9: Experiment Design II | Python Code:
# Uncomment to install required python modules
# !sh ../utils/setup.sh
# Add custom utils module to Python environment
import os
import sys
sys.path.append(os.path.abspath(os.pardir))
import numpy as np
import pandas as pd
from gps_building_blocks.analysis.exp_design import ab_testing_design
from gps_building_blocks.cloud.utils import bigquery as bigquery_utils
from utils import helpers
Explanation: 6. Media experiment design
This notebook demonstrates the design of a media experiment by using the
Experimental Desing
module to activate the predictions from a propensity model. It is vital to design and estimate the impact of media campaigns using valid statistical methods to make sure the limited experimentation budget is utilized effectively and to set the right expectations of the campaign outcome.
Requirements
An already scored test dataset, or the model and the test dataset to be scored available in GCP BigQuery.
This test dataset should contain all the ML instances for at least one snapshot date.
Install and import required modules
End of explanation
# Prints all the outputs from cell (instead of using display each time).
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = 'all'
Explanation: Notebook custom settings
End of explanation
configs = helpers.get_configs('config.yaml')
dest_configs, run_id_configs = configs.destination, configs.run_id
# GCP project ID
PROJECT_ID = dest_configs.project_id
# Name of the BigQuery dataset
DATASET_NAME = dest_configs.dataset_name
# To distinguish the separate runs of the training pipeline
RUN_ID = run_id_configs.train
# BigQuery table name containing the test dataset to be scored. This test
# dataset should contain all the instances at least for one snapshot date
FEATURES_TEST_TABLE = f'features_test_table_{RUN_ID}'
# BigQuery model name
MODEL_NAME = f'propensity_model_{RUN_ID}'
# BigQuery table name containing the scored test dataset.
FEATURES_TEST_PREDICTIONS_TABLE = f'features_test_table_preds_{RUN_ID}'
# Selected snapshot date to select the ML instances (reflecting the instances to
# be scored on a given scoring date) to be used for experiment design in
# YYYY-MM-DD format
SELECTED_SNAPSHOT_DATE = '2017-06-15'
# Name of the actual label column
ACTUAL_LABEL_NAME = 'label'
# Name of the prediction column
PREDICTED_LABEL_NAME = 'predicted_label_probs'
# Label value for the positive class
POSITIVE_CLASS_LABEL = True
# BigQuery client object
bq_utils = bigquery_utils.BigQueryUtils(project_id=PROJECT_ID)
Explanation: Set parameters
End of explanation
# Prediction sql query
# TODO(): Filter deliberately data for ML.Predict
prediction_query =f
SELECT *
FROM ML.PREDICT(MODEL `{PROJECT_ID}.{DATASET_NAME}.{MODEL_NAME}`,
TABLE `{PROJECT_ID}.{DATASET_NAME}.{FEATURES_TEST_TABLE}`)
WHERE snapshot_ts='{SELECTED_SNAPSHOT_DATE}';
# Run prediction
print(prediction_query)
df_test_predictions = bq_utils.run_query(prediction_query).to_dataframe()
# Size of the prediction data frame
print(df_test_predictions.shape)
Explanation: Select the relevant data for experiment design
Select all the instances for one snapshot date, which resembles the scoring dataset for one day. This dataset is used to design the media experiment.
Score the test dataset (if not already scored)
End of explanation
# Data read in sql query
read_query = f
SELECT
predictions.label AS label,
predicted_label,
probs.label AS predicted_score_label,
probs.prob AS score,
snapshot_ts
FROM
`{PROJECT_ID}.{DATASET_NAME}.{FEATURES_TEST_PREDICTIONS_TABLE}` AS predictions,
UNNEST({PREDICTED_LABEL_NAME}) AS probs
WHERE
probs.label={POSITIVE_CLASS_LABEL}
AND snapshot_ts = '{SELECTED_SNAPSHOT_DATE}';
# Run prediction
print(read_query)
df_test_predictions = bq_utils.run_query(read_query).to_dataframe()
# Size of the prediction data frame
print(df_test_predictions.shape)
Explanation: Read the prediction test dataset (if already scored)
End of explanation
df_test_predictions.head()
# Change positive label into 1.0.
df_test_predictions['label_numerical'] = [
1.0 if label == POSITIVE_CLASS_LABEL else 0.0
for label in df_test_predictions[ACTUAL_LABEL_NAME]]
# Check transformed values
label_before = df_test_predictions['label'].value_counts()
label_after = df_test_predictions['label_numerical'].value_counts()
df_labels_check = pd.DataFrame(data = {'label_before': label_before,
'label_after': label_after})
df_labels_check['is_label_same'] = (
df_labels_check['label_before'] == df_labels_check['label_after'])
df_labels_check
Explanation: Prepare probability and label columns
End of explanation
ab_testing_design.calc_chisquared_sample_sizes_for_bins(
labels=df_test_predictions['label_numerical'].values,
probability_predictions=df_test_predictions['score'].values,
number_bins=3, # to have High, Medium and Low bins
uplift_percentages=(10, 15), # minimum expected effect sizes
power_percentages=(80, 90),
confidence_level_percentages=(90, 95))
Explanation: Experiment Design I: Different Propensity Groups
One way to use the output from a Propensity Model to optimize marketing is to first define different audience groups based on the predicted probabilities (such as High, Medium and Low propensity groups) and then test the same or different marketing strategies with those. This strategy is more useful to understand how different propensity groups respond to remarketing campaigns.
Following step estimates the statistical sample sizes required for different groups (bins) of the predicted probabilities based on different combinations of the expected minimum uplift/effect size, statistical power and statistical confidence levels specified as input parameters.
Expected output: a Pandas Dataframe containing statistical sample size for each bin for each combination of minimum uplift_percentage, statistical power and statistical confidence level.
Based on the estimated sample sizes and the available sizes one can decide what setting (expected minimum uplift/effect size at a given statistical power and a confidence level) to be selected for the experiment. Then the selected sample sizes could be used to set Test and Control cohorts from each propensity group to implement the media experiment.
End of explanation
ab_testing_design.calc_chisquared_sample_sizes_for_cumulative_bins(
labels=df_test_predictions['label_numerical'].values,
probability_predictions=df_test_predictions['score'].values,
number_bins=10, # top 10%, 20%, ..., 100%
uplift_percentages=(10, 15), # minimum expected effect sizes
power_percentages=(80, 90),
confidence_level_percentages=(90, 95))
Explanation: Experiment Design II: Top Propensity Group
Another way to use the output from a Propensity Model to optimize marketing is to target the top X% of users having the highest predicted probability score in a remarketing campaign or an acquisition campaigns with the similar audience strategy.
Following step estimates the statistical sample sizes required for different cumulative groups (bins) of the predicted probabilities (top X%, top 2X% and so on) based on different combinations of the expected minimum uplift/effect size, statistical power and statistical confidence levels specified as input parameters.
Expected output: a Pandas Dataframe containing statistical sample size for each cumulative bin for each combination of minimum uplift_percentage, statistical power and statistical confidence level.
Based on the estimated sample sizes and the available sizes one can decide what setting (what top X% of users with the expected minimum uplift/effect size at a given statistical power and a confidence level) to be selected for the experiment. Then the selected sample size could be used to set Test and Control cohorts from the top X% to implement the media experiment.
End of explanation |
3,414 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Deploying an XGBoost model on Verta
Within Verta, a "Model" can be any arbitrary function
Step1: 0.1 Verta import and setup
Step2: 1. Model training
1.1 Prepare Data
Step3: 1.2 Prepare Hyperparameters
Step4: 1.3 Train the model and tune hyperparameters
Step5: 1.4 Select the best set of hyperparams and train on full dataset
Step6: 2. Register Model for Deployment
Step7: 3. Deploy model to endpoint | Python Code:
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
import itertools
import time
import six
import numpy as np
import pandas as pd
import sklearn
from sklearn import datasets
from sklearn import model_selection
import xgboost as xgb
Explanation: Deploying an XGBoost model on Verta
Within Verta, a "Model" can be any arbitrary function: a traditional ML model (e.g., sklearn, PyTorch, TF, etc); a function (e.g., squaring a number, making a DB function etc.); or a mixture of the above (e.g., pre-processing code, a DB call, and then a model application.) See more here.
This notebook provides an example of how to deploy a XGBoost model on Verta as a Verta Standard Model either via convenience functions or by extending VertaModelBase.
<a href="https://colab.research.google.com/github/VertaAI/modeldb/blob/master/client/workflows/examples/xgboost.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
0. Imports
End of explanation
# restart your notebook if prompted on Colab
try:
import verta
except ImportError:
!pip install verta
import os
# Ensure credentials are set up, if not, use below
# os.environ['VERTA_EMAIL'] =
# os.environ['VERTA_DEV_KEY'] =
# os.environ['VERTA_HOST'] =
from verta import Client
import os
client = Client(os.environ['VERTA_HOST'])
PROJECT_NAME = "Wine Multiclassification"
EXPERIMENT_NAME = "Boosted Trees"
proj = client.set_project(PROJECT_NAME)
expt = client.set_experiment(EXPERIMENT_NAME)
Explanation: 0.1 Verta import and setup
End of explanation
data = datasets.load_wine()
X = data['data']
y = data['target']
dtrain = xgb.DMatrix(X, label=y)
df = pd.DataFrame(np.hstack((X, y.reshape(-1, 1))),
columns=data['feature_names'] + ['species'])
df.head()
Explanation: 1. Model training
1.1 Prepare Data
End of explanation
grid = model_selection.ParameterGrid({
'eta': [0.5, 0.7],
'max_depth': [1, 2, 3],
'num_class': [10],
})
Explanation: 1.2 Prepare Hyperparameters
End of explanation
def run_experiment(hyperparams):
run = client.set_experiment_run()
# log hyperparameters
run.log_hyperparameters(hyperparams)
# run cross validation on hyperparameters
cv_history = xgb.cv(hyperparams, dtrain,
nfold=5,
metrics=("merror", "mlogloss"))
# log observations from each iteration
for _, iteration in cv_history.iterrows():
for obs, val in iteration.iteritems():
run.log_observation(obs, val)
# log error from final iteration
final_val_error = iteration['test-merror-mean']
run.log_metric("val_error", final_val_error)
print("{} Mean error: {:.4f}".format(hyperparams, final_val_error))
# NOTE: run_experiment() could also be defined in a module, and executed in parallel
for hyperparams in grid:
run_experiment(hyperparams)
Explanation: 1.3 Train the model and tune hyperparameters
End of explanation
best_run = expt.expt_runs.sort("metrics.val_error", descending=False)[0]
print("Validation Error: {:.4f}".format(best_run.get_metric("val_error")))
best_hyperparams = best_run.get_hyperparameters()
print("Hyperparameters: {}".format(best_hyperparams))
model = xgb.XGBClassifier(**best_hyperparams)
model.fit(X, y)
# Calculate and Log Accuracy on Full Training Set
train_acc = model.score(X, y)
best_run.log_metric("train_acc_full", train_acc)
print("Training accuracy: {:.4f}".format(train_acc))
Explanation: 1.4 Select the best set of hyperparams and train on full dataset
End of explanation
registered_model = client.get_or_create_registered_model(
name="wine", labels=["xgboost"])
from verta.environment import Python
model_version = registered_model.create_standard_model_from_xgboost(
model, environment=Python(requirements=["xgboost", "sklearn"]), name="v1")
Explanation: 2. Register Model for Deployment
End of explanation
wine_endpoint = client.get_or_create_endpoint("wine")
wine_endpoint.update(model_version, wait=True)
deployed_model = wine_endpoint.get_deployed_model()
deployed_model.predict([X[0]])
Explanation: 3. Deploy model to endpoint
End of explanation |
3,415 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Step7: Chapter 7
Step9: Using global variables is not considered a good development practice, as they make the system harder to understand, so it is better to avoid their use. The same applies to overshadowing variables.
Step12: NOTE | Python Code:
a = 10
def test():
print(a)
a = 12
test()
print(a)
a = 10
def test():
a = 12
print(a)
test()
print(a)
a = 10
def test():
- Only for viewing value of Global Variable
- Cannot change the global variable
print(a)
test()
print(a)
a = 10
def test():
- When you need to update the value of Global variable
global a
print(a)
a = 12
print(a)
print(id(a))
# print(locals())
# print(globals())
print(a)
test()
print(id(a))
print(a)
def test():
Updating the data
global glb
print(glb)
glb = 12
test()
glb = 10
print(glb)
def test():
Updating the data
global glb
print(glb)
glb = 12
glb = 10
test()
print(glb)
def test():
Updating the data
global glb1
glb1 = 12
print(glb1)
test()
print(glb)
a = 10
def test():
global a
a = "Chennai Riders"
print(a)
a = "Pune Rocks"
test()
print(a)
global a
a = 10
def test():
a = "Pune Rocks"
print(a)
print(locals())
print("~"*20)
# print(globals())
test()
print(a)
a = 10
def test(a):
print(a)
a = "Pune Rocks"
print(locals())
return a
a= test(a)
print(a)
print(len(locals()))
print(len(globals()))
def addlist(lists):
Add lists of lists, recursively
the result is global
global add
for item in lists:
if isinstance(item, list): # If item type is list
addlist(item)
else:
add += item # add = add + item
add = 0
addlist([[1, 2], [3, 4, 5], 6])
print(add)
# add = 10
def addlist(lists):
Add lists of lists, recursively
the result is global
global add2
for item in lists:
if isinstance(item, list): # If item type is list
addlist(item)
else:
if 'add2' in globals():
add2 += item
else:
print("Creating add")
add2 = item
addlist([[1, 2], [3, 4, 5], 6])
print(add2)
Explanation: Chapter 7: Scope of names
The scope of names (variables) are maintained by Namespaces, which are dictionaries containing the names of the objects (references) and the objects themselves.
As we have seen that names are not pre-defined thus Python uses the code block of the assignment of a name to associate it with a particular namespace. In other words, the place where you assign a name in your source code determines its scope of visibility.
Python uses lexical scoping, which means that variable scopes are determined entirely by their locations in the source code and not by function calls.
Rules for names inside Functions are as follows
Names assigned inside a def can only be seen by the code within that def and cannot be referred from outside the function.
Names assigned inside a def do'nt clash with variables from outside the def. i.e. a name assigned outside a def is a completely different variable from a name assigned inside that def.
If a variable is assigned outside all defs, then it is global to the entire file and can be accessed with the help of global keyword inside the def.
Normally, the names are defined in two dictionaries, which can be accessed through the functions locals() and globals(). These dictionaries are updated dynamically at <span class="note" title="Although the dictionaries returned by locals() and globals() can be changed directly, this should be avoided because it can have undesirable effects.">runtime</span>.
Global variables can be overshadowed by local variables (because the local scope is consulted before the global scope). To avoid this, you must declare the variable as global in the local scope.
example:
End of explanation
#add = 10
def addlist(lists):
Add lists of lists, recursively
the result is global
global add
for item in lists:
if isinstance(item, list): # If item type is list
addlist(item)
x = 100
else:
add += item
print(x)
addlist([[1, 2], [3, 4, 5], 6])
print(add)
def outer():
a = 0
b = 1
def inner():
print(a)
print(b)
inner()
outer()
Explanation: Using global variables is not considered a good development practice, as they make the system harder to understand, so it is better to avoid their use. The same applies to overshadowing variables.
End of explanation
def outer():
a = 0
b = 1
def inner():
print(a)
print(b)
b = 4
inner()
outer()
def outer():
a = 0
print("outer: ", a)
def inner():
global a
print("inner: ", a)
inner()
a = 200
b = 10
outer()
print("base")
print(a)
print(b)
def List_fun(l, a=[]):
function takes 2 parameters list having values and empty list.
for i in l:
#checking whether the values are list or not
if isinstance(i, list):
List_fun(i, a)
else:
a.append(i)
return a
b=[]
l2 = List_fun([[1,2],[3,[4,5]],6,7], b)
print(l2)
print(b)
print(id(l2))
print(id(b))
def List_fun(l, a=[]):
function takes 2 parameters list having values and empty list.
for i in l:
#checking whether the values are list or not
if isinstance(i, list):
List_fun(i, a)
else:
a.append(i)
b=[]
List_fun([[1,2],[3,[4,5]],6,7], b)
print(b)
def fun_numbers(a):
print(a)
print(id(a))
a += 10
print(a)
print(id(a))
b = 10
print(id(b))
fun_numbers(b)
print(b)
def fun_numbers(a):
print(a)
print(id(a))
a = [20]
print(a)
print(id(a))
b = [10]
print(id(b))
fun_numbers(b)
print(b)
def fun_numbers(a):
print(a)
print(id(a))
a.append(20)
print(a)
print(id(a))
b = [10]
print(id(b))
fun_numbers(b)
print(b)
def fun_numbers(a):
print(a)
a.append(120)
print(a)
b = [10]
fun_numbers(b)
print(b)
def func():
a = 10
for d in [10,20,30]:
a = a+d
print(a)
func()
Explanation: NOTE: - A special quirk of Python is that – if no global statement is in effect – assignments to names always go into the innermost scope. Assignments do not copy data — they just bind names to objects.
End of explanation |
3,416 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Jha et al. 2007
Title
Step1: Table 1
Uncomment out the line below or download directly from the Paper's ApJ Website | Python Code:
%matplotlib inline
%config InlineBackend.figure_format = 'retina'
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#! mkdir ../data/Jha2007
Explanation: Jha et al. 2007
Title: Improved Distances to Type Ia Supernovae with Multicolor Light-Curve Shapes: MLCS2k2
Authors: Saurabh Jha, Adam G. Riess, and Robert P. Kirshner
ADS: http://adsabs.harvard.edu/abs/2007ApJ...659..122J
End of explanation
#! wget -P ../data/Jha_2007ApJ...659..122J/ -e html_extension=Off http://iopscience.iop.org/article/10.1086/512054/fulltext/63969.tb1.txt
! head -n 4 ../data/Jha2007/63969.tb1.txt
names = ['SN_Ia','galactic_longitude','galactic_latitude','cz_km_s_sun','cz_km_s_LG',
'cz_km_s_CMB','morphological_type','SN_offset_N_as','SN_offset_E_as','t_1_days',
'filters','E_B_V','Refs']
df_tbl1 = pd.read_csv('../data/Jha2007/63969.tb1.txt', names=names,
delim_whitespace=True, na_values='\ldots')
df_tbl1.tail()
import matplotlib.ticker as plticker
fig,ax=plt.subplots(figsize=(8,8))
#Spacing between each line
intervals = 1.0
loc = plticker.MultipleLocator(base=intervals)
ax.xaxis.set_major_locator(loc)
ax.yaxis.set_major_locator(loc)
# Add the grid
ax.grid(which='major', axis='both', linestyle='-')
ax.plot(df_tbl1.SN_offset_E_as/4.0, df_tbl1.SN_offset_N_as/4.0, '.')
ax.plot([0], [0], 'ro')
ax.set_xlim(-25, 25)
ax.set_ylim(-25, 25)
ax.xaxis.set_ticklabels([])
ax.yaxis.set_ticklabels([])
ax.set_title('Host galaxy type Ia supernovae distances')
ax.set_xlabel('Kepler pixels')
ax.set_ylabel('Kepler pixels');
rad_dist = np.sqrt(df_tbl1.SN_offset_E_as**2 + df_tbl1.SN_offset_N_as**2)
import seaborn as sns
sns.distplot(rad_dist/4.0)
plt.xlabel('$N$ Kepler pixels');
np.percentile(rad_dist/4.0, 80)
Explanation: Table 1
Uncomment out the line below or download directly from the Paper's ApJ Website
End of explanation |
3,417 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Advanced Custom Primitives Guide
Step1: Primitives with Additional Arguments
Some features require more advanced calculations than others. Advanced features usually entail additional arguments to help output the desired value. With custom primitives, you can use primitive arguments to help you create advanced features.
String Count Example
In this example, you will learn how to make custom primitives that take in additional arguments. You will create a primitive to count the number of times a specific string value occurs inside a text.
First, derive a new transform primitive class using TransformPrimitive as a base. The primitive will take in a text column as the input and return a numeric column as the output, so set the input type to a Woodwork ColumnSchema with logical type NaturalLanguage and the return type to a Woodwork ColumnSchema with the semantic tag 'numeric'. The specific string value is the additional argument, so define it as a keyword argument inside __init__. Then, override get_function to return a primitive function that will calculate the feature.
Featuretools' primitives use Woodwork's ColumnSchema to control the input and return types of columns for the primitive. For more information about using the Woodwork typing system in Featuretools, see the Woodwork Typing in Featuretools guide.
Step2: Now you have a primitive that is reusable for different string values. For example, you can create features based on the number of times the word "the" appears in a text. Create an instance of the primitive where the string value is "the" and pass the primitive into DFS to generate the features. The feature name will automatically reflect the string value of the primitive.
Step3: Features with Multiple Outputs
Some calculations output more than a single value. With custom primitives, you can make the most of these calculations by creating a feature for each output value.
Case Count Example
In this example, you will learn how to make custom primitives that output multiple features. You will create a primitive that outputs the count of upper case and lower case letters of a text.
First, derive a new transform primitive class using TransformPrimitive as a base. The primitive will take in a text column as the input and return two numeric columns as the output, so set the input type to a Woodwork ColumnSchema with logical type NaturalLanguage and the return type to a Woodwork ColumnSchema with semantic tag 'numeric'. Since this primitive returns two columns, also set number_output_features to two. Then, override get_function to return a primitive function that will calculate the feature and return a list of columns.
Step4: Now you have a primitive that outputs two columns. One column contains the count for the upper case letters. The other column contains the count for the lower case letters. Pass the primitive into DFS to generate features. By default, the feature name will reflect the index of the output.
Step5: Custom Naming for Multiple Outputs
When you create a primitive that outputs multiple features, you can also define custom naming for each of those features.
Hourly Sine and Cosine Example
In this example, you will learn how to apply custom naming for multiple outputs. You will create a primitive that outputs the sine and cosine of the hour.
First, derive a new transform primitive class using TransformPrimitive as a base. The primitive will take in the time index as the input and return two numeric columns as the output. Set the input type to a Woodwork ColumnSchema with a logical type of Datetime and the semantic tag 'time_index'. Next, set the return type to a Woodwork ColumnSchema with semantic tag 'numeric' and set number_output_features to two. Then, override get_function to return a primitive function that will calculate the feature and return a list of columns. Also, override generate_names to return a list of the feature names that you define.
Step6: Now you have a primitive that outputs two columns. One column contains the sine of the hour. The other column contains the cosine of the hour. Pass the primitive into DFS to generate features. The feature name will reflect the custom naming you defined. | Python Code:
from featuretools.primitives import TransformPrimitive
from featuretools.tests.testing_utils import make_ecommerce_entityset
from woodwork.column_schema import ColumnSchema
from woodwork.logical_types import Datetime, NaturalLanguage
import featuretools as ft
import numpy as np
import re
Explanation: Advanced Custom Primitives Guide
End of explanation
class StringCount(TransformPrimitive):
'''Count the number of times the string value occurs.'''
name = 'string_count'
input_types = [ColumnSchema(logical_type=NaturalLanguage)]
return_type = ColumnSchema(semantic_tags={'numeric'})
def __init__(self, string=None):
self.string = string
def get_function(self):
def string_count(column):
assert self.string is not None, "string to count needs to be defined"
# this is a naive implementation used for clarity
counts = [text.lower().count(self.string) for text in column]
return counts
return string_count
Explanation: Primitives with Additional Arguments
Some features require more advanced calculations than others. Advanced features usually entail additional arguments to help output the desired value. With custom primitives, you can use primitive arguments to help you create advanced features.
String Count Example
In this example, you will learn how to make custom primitives that take in additional arguments. You will create a primitive to count the number of times a specific string value occurs inside a text.
First, derive a new transform primitive class using TransformPrimitive as a base. The primitive will take in a text column as the input and return a numeric column as the output, so set the input type to a Woodwork ColumnSchema with logical type NaturalLanguage and the return type to a Woodwork ColumnSchema with the semantic tag 'numeric'. The specific string value is the additional argument, so define it as a keyword argument inside __init__. Then, override get_function to return a primitive function that will calculate the feature.
Featuretools' primitives use Woodwork's ColumnSchema to control the input and return types of columns for the primitive. For more information about using the Woodwork typing system in Featuretools, see the Woodwork Typing in Featuretools guide.
End of explanation
es = make_ecommerce_entityset()
feature_matrix, features = ft.dfs(
entityset=es,
target_dataframe_name="sessions",
agg_primitives=["sum", "mean", "std"],
trans_primitives=[StringCount(string="the")],
)
feature_matrix[[
'STD(log.STRING_COUNT(comments, string=the))',
'SUM(log.STRING_COUNT(comments, string=the))',
'MEAN(log.STRING_COUNT(comments, string=the))',
]]
Explanation: Now you have a primitive that is reusable for different string values. For example, you can create features based on the number of times the word "the" appears in a text. Create an instance of the primitive where the string value is "the" and pass the primitive into DFS to generate the features. The feature name will automatically reflect the string value of the primitive.
End of explanation
class CaseCount(TransformPrimitive):
'''Return the count of upper case and lower case letters of a text.'''
name = 'case_count'
input_types = [ColumnSchema(logical_type=NaturalLanguage)]
return_type = ColumnSchema(semantic_tags={'numeric'})
number_output_features = 2
def get_function(self):
def case_count(array):
# this is a naive implementation used for clarity
upper = np.array([len(re.findall('[A-Z]', i)) for i in array])
lower = np.array([len(re.findall('[a-z]', i)) for i in array])
return upper, lower
return case_count
Explanation: Features with Multiple Outputs
Some calculations output more than a single value. With custom primitives, you can make the most of these calculations by creating a feature for each output value.
Case Count Example
In this example, you will learn how to make custom primitives that output multiple features. You will create a primitive that outputs the count of upper case and lower case letters of a text.
First, derive a new transform primitive class using TransformPrimitive as a base. The primitive will take in a text column as the input and return two numeric columns as the output, so set the input type to a Woodwork ColumnSchema with logical type NaturalLanguage and the return type to a Woodwork ColumnSchema with semantic tag 'numeric'. Since this primitive returns two columns, also set number_output_features to two. Then, override get_function to return a primitive function that will calculate the feature and return a list of columns.
End of explanation
feature_matrix, features = ft.dfs(
entityset=es,
target_dataframe_name="sessions",
agg_primitives=[],
trans_primitives=[CaseCount],
)
feature_matrix[[
'customers.CASE_COUNT(favorite_quote)[0]',
'customers.CASE_COUNT(favorite_quote)[1]',
]]
Explanation: Now you have a primitive that outputs two columns. One column contains the count for the upper case letters. The other column contains the count for the lower case letters. Pass the primitive into DFS to generate features. By default, the feature name will reflect the index of the output.
End of explanation
class HourlySineAndCosine(TransformPrimitive):
'''Returns the sine and cosine of the hour.'''
name = 'hourly_sine_and_cosine'
input_types = [ColumnSchema(logical_type=Datetime, semantic_tags={'time_index'})]
return_type = ColumnSchema(semantic_tags={'numeric'})
number_output_features = 2
def get_function(self):
def hourly_sine_and_cosine(column):
sine = np.sin(column.dt.hour)
cosine = np.cos(column.dt.hour)
return sine, cosine
return hourly_sine_and_cosine
def generate_names(self, base_feature_names):
name = self.generate_name(base_feature_names)
return f'{name}[sine]', f'{name}[cosine]'
Explanation: Custom Naming for Multiple Outputs
When you create a primitive that outputs multiple features, you can also define custom naming for each of those features.
Hourly Sine and Cosine Example
In this example, you will learn how to apply custom naming for multiple outputs. You will create a primitive that outputs the sine and cosine of the hour.
First, derive a new transform primitive class using TransformPrimitive as a base. The primitive will take in the time index as the input and return two numeric columns as the output. Set the input type to a Woodwork ColumnSchema with a logical type of Datetime and the semantic tag 'time_index'. Next, set the return type to a Woodwork ColumnSchema with semantic tag 'numeric' and set number_output_features to two. Then, override get_function to return a primitive function that will calculate the feature and return a list of columns. Also, override generate_names to return a list of the feature names that you define.
End of explanation
feature_matrix, features = ft.dfs(
entityset=es,
target_dataframe_name="log",
agg_primitives=[],
trans_primitives=[HourlySineAndCosine],
)
feature_matrix.head()[[
'HOURLY_SINE_AND_COSINE(datetime)[sine]',
'HOURLY_SINE_AND_COSINE(datetime)[cosine]',
]]
Explanation: Now you have a primitive that outputs two columns. One column contains the sine of the hour. The other column contains the cosine of the hour. Pass the primitive into DFS to generate features. The feature name will reflect the custom naming you defined.
End of explanation |
3,418 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Basic Control Structures in Python
Loops allow us to repeatedly execute parts of a program (most of the time with a variable parameter)
Conditional program execution allow us to execute parts of a program depending on some condition
The while-loop
The basic sytax of the while-loop in Python is
Step1: Notes
Step2: The square root $y=\sqrt{x}$ of a positive number $x$ can be estimated iteratively with $y_0>0$ (an arbitrary positive number) and $y_{n+1}=\frac 12\left(y_n+\frac{x}{y_n}\right)$.
Write a python program to estimate the square root with that recipe!
Hint
Step3: The if-statement
The basic syntax of the ìf-statement is
Step4: Exercises
Step5: Write a program to test whether a given positive integer $x$ is a prime number!
Hints | Python Code:
# print the squares of the numbers 1 to 10
i = 1
while i <= 10:
print(i**2)
i = i + 1
print("The loop has finished")
Explanation: Basic Control Structures in Python
Loops allow us to repeatedly execute parts of a program (most of the time with a variable parameter)
Conditional program execution allow us to execute parts of a program depending on some condition
The while-loop
The basic sytax of the while-loop in Python is:
while condition:
# execute commands until condition
# evaluates to False
End of explanation
# your solution here
Explanation: Notes:
condition must be a boolean expression! The loop is executed while the condition evaluates to True.
Note the colon at the end of the condition!
Python has no special characters indicating the start and the end of
the while-loop execution block. The block is merely indicated by identation!
This is the case for all Python control structures! Blocks are always indicated
by code-identation. All lines belonging to a block must be idented by the same
amount of spaces. The usual ident is four spaces (never use tabs).
Exercises
What is the output of the print statements in the following code fragements? Answer the question before executing the codes!
a = 1
i = 1
while i < 5:
i = i + 1
a = a + 1
print(i, a)
and
a = 1
i = 1
while i < 5:
i = i + 1
a = a + 1
print(i, a)
End of explanation
# your solution here
Explanation: The square root $y=\sqrt{x}$ of a positive number $x$ can be estimated iteratively with $y_0>0$ (an arbitrary positive number) and $y_{n+1}=\frac 12\left(y_n+\frac{x}{y_n}\right)$.
Write a python program to estimate the square root with that recipe!
Hint: Construct a while-loop with the condition $|y_{n+1}-y_n|>\epsilon$ with $\epsilon=10^{-6}$ and update $y_n$ and $y_{n+1}$ within the loop. Consider the final $y_{n+1}$ as estimate for $\sqrt{x}$.
End of explanation
x = 6
if x < 10:
print("x is smaller than 10!")
if x % 2 == 0:
print("x is even!")
else:
print("x is odd!")
Explanation: The if-statement
The basic syntax of the ìf-statement is:
if condition:
# execute commands if condition is True
else:
# execute commands if condition is False
The else-part of the construct is optional!
The same notes as for the while-loop apply!
End of explanation
# your solution here
Explanation: Exercises:
$x$ and $y$ are integer numbers. Write a python program which determines whether $x<y$, $x>y$ or $x=y$ and prints out the result!
Hint: Nested if-statements
End of explanation
# your solution here
Explanation: Write a program to test whether a given positive integer $x$ is a prime number!
Hints:
- You need a combination of a while-loop and an if-statement.
- A very simple test for the prime-property is: A positive integer is prime if $x\bmod n \neq 0$ for all $2\leq n \leq \sqrt{x}$.
End of explanation |
3,419 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
The role of dipole orientations in distributed source localization
When performing source localization in a distributed manner
(MNE/dSPM/sLORETA/eLORETA),
the source space is defined as a grid of dipoles that spans a large portion of
the cortex. These dipoles have both a position and an orientation. In this
tutorial, we will look at the various options available to restrict the
orientation of the dipoles and the impact on the resulting source estimate.
See inverse_orientation_constraints for related information.
Loading data
Load everything we need to perform source localization on the sample dataset.
Step1: The source space
Let's start by examining the source space as constructed by the
Step2: Fixed dipole orientations
While the source space defines the position of the dipoles, the inverse
operator defines the possible orientations of them. One of the options is to
assign a fixed orientation. Since the neural currents from which MEG and EEG
signals originate flows mostly perpendicular to the cortex [1]_, restricting
the orientation of the dipoles accordingly places a useful restriction on the
source estimate.
By specifying fixed=True when calling
Step3: Restricting the dipole orientations in this manner leads to the following
source estimate for the sample data
Step4: The direction of the estimated current is now restricted to two directions
Step5: When computing the source estimate, the activity at each of the three dipoles
is collapsed into the XYZ components of a single vector, which leads to the
following source estimate for the sample data
Step6: Limiting orientations, but not fixing them
Often, the best results will be obtained by allowing the dipoles to have
somewhat free orientation, but not stray too far from a orientation that is
perpendicular to the cortex. The loose parameter of the
Step7: Discarding dipole orientation information
Often, further analysis of the data does not need information about the
orientation of the dipoles, but rather their magnitudes. The pick_ori
parameter of the | Python Code:
import mne
import numpy as np
from mne.datasets import sample
from mne.minimum_norm import make_inverse_operator, apply_inverse
data_path = sample.data_path()
evokeds = mne.read_evokeds(data_path + '/MEG/sample/sample_audvis-ave.fif')
left_auditory = evokeds[0].apply_baseline()
fwd = mne.read_forward_solution(
data_path + '/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif')
mne.convert_forward_solution(fwd, surf_ori=True, copy=False)
noise_cov = mne.read_cov(data_path + '/MEG/sample/sample_audvis-cov.fif')
subject = 'sample'
subjects_dir = data_path + '/subjects'
trans_fname = data_path + '/MEG/sample/sample_audvis_raw-trans.fif'
Explanation: The role of dipole orientations in distributed source localization
When performing source localization in a distributed manner
(MNE/dSPM/sLORETA/eLORETA),
the source space is defined as a grid of dipoles that spans a large portion of
the cortex. These dipoles have both a position and an orientation. In this
tutorial, we will look at the various options available to restrict the
orientation of the dipoles and the impact on the resulting source estimate.
See inverse_orientation_constraints for related information.
Loading data
Load everything we need to perform source localization on the sample dataset.
End of explanation
lh = fwd['src'][0] # Visualize the left hemisphere
verts = lh['rr'] # The vertices of the source space
tris = lh['tris'] # Groups of three vertices that form triangles
dip_pos = lh['rr'][lh['vertno']] # The position of the dipoles
dip_ori = lh['nn'][lh['vertno']]
dip_len = len(dip_pos)
dip_times = [0]
white = (1.0, 1.0, 1.0) # RGB values for a white color
actual_amp = np.ones(dip_len) # misc amp to create Dipole instance
actual_gof = np.ones(dip_len) # misc GOF to create Dipole instance
dipoles = mne.Dipole(dip_times, dip_pos, actual_amp, dip_ori, actual_gof)
trans = mne.read_trans(trans_fname)
fig = mne.viz.create_3d_figure(size=(600, 400), bgcolor=white)
coord_frame = 'mri'
# Plot the cortex
fig = mne.viz.plot_alignment(subject=subject, subjects_dir=subjects_dir,
trans=trans, surfaces='white',
coord_frame=coord_frame, fig=fig)
# Mark the position of the dipoles with small red dots
fig = mne.viz.plot_dipole_locations(dipoles=dipoles, trans=trans,
mode='sphere', subject=subject,
subjects_dir=subjects_dir,
coord_frame=coord_frame,
scale=7e-4, fig=fig)
mne.viz.set_3d_view(figure=fig, azimuth=180, distance=0.25)
Explanation: The source space
Let's start by examining the source space as constructed by the
:func:mne.setup_source_space function. Dipoles are placed along fixed
intervals on the cortex, determined by the spacing parameter. The source
space does not define the orientation for these dipoles.
End of explanation
fig = mne.viz.create_3d_figure(size=(600, 400))
# Plot the cortex
fig = mne.viz.plot_alignment(subject=subject, subjects_dir=subjects_dir,
trans=trans,
surfaces='white', coord_frame='head', fig=fig)
# Show the dipoles as arrows pointing along the surface normal
fig = mne.viz.plot_dipole_locations(dipoles=dipoles, trans=trans,
mode='arrow', subject=subject,
subjects_dir=subjects_dir,
coord_frame='head',
scale=7e-4, fig=fig)
mne.viz.set_3d_view(figure=fig, azimuth=180, distance=0.1)
Explanation: Fixed dipole orientations
While the source space defines the position of the dipoles, the inverse
operator defines the possible orientations of them. One of the options is to
assign a fixed orientation. Since the neural currents from which MEG and EEG
signals originate flows mostly perpendicular to the cortex [1]_, restricting
the orientation of the dipoles accordingly places a useful restriction on the
source estimate.
By specifying fixed=True when calling
:func:mne.minimum_norm.make_inverse_operator, the dipole orientations are
fixed to be orthogonal to the surface of the cortex, pointing outwards. Let's
visualize this:
End of explanation
# Compute the source estimate for the 'left - auditory' condition in the sample
# dataset.
inv = make_inverse_operator(left_auditory.info, fwd, noise_cov, fixed=True)
stc = apply_inverse(left_auditory, inv, pick_ori=None)
# Visualize it at the moment of peak activity.
_, time_max = stc.get_peak(hemi='lh')
brain_fixed = stc.plot(surface='white', subjects_dir=subjects_dir,
initial_time=time_max, time_unit='s', size=(600, 400))
Explanation: Restricting the dipole orientations in this manner leads to the following
source estimate for the sample data:
End of explanation
fig = mne.viz.create_3d_figure(size=(600, 400))
# Plot the cortex
fig = mne.viz.plot_alignment(subject=subject, subjects_dir=subjects_dir,
trans=trans,
surfaces='white', coord_frame='head', fig=fig)
# Show the three dipoles defined at each location in the source space
fig = mne.viz.plot_alignment(subject=subject, subjects_dir=subjects_dir,
trans=trans, fwd=fwd,
surfaces='white', coord_frame='head', fig=fig)
mne.viz.set_3d_view(figure=fig, azimuth=180, distance=0.1)
Explanation: The direction of the estimated current is now restricted to two directions:
inward and outward. In the plot, blue areas indicate current flowing inwards
and red areas indicate current flowing outwards. Given the curvature of the
cortex, groups of dipoles tend to point in the same direction: the direction
of the electromagnetic field picked up by the sensors.
Loose dipole orientations
Forcing the source dipoles to be strictly orthogonal to the cortex makes the
source estimate sensitive to the spacing of the dipoles along the cortex,
since the curvature of the cortex changes within each ~10 square mm patch.
Furthermore, misalignment of the MEG/EEG and MRI coordinate frames is more
critical when the source dipole orientations are strictly constrained [2]_.
To lift the restriction on the orientation of the dipoles, the inverse
operator has the ability to place not one, but three dipoles at each
location defined by the source space. These three dipoles are placed
orthogonally to form a Cartesian coordinate system. Let's visualize this:
End of explanation
# Make an inverse operator with loose dipole orientations
inv = make_inverse_operator(left_auditory.info, fwd, noise_cov, fixed=False,
loose=1.0)
# Compute the source estimate, indicate that we want a vector solution
stc = apply_inverse(left_auditory, inv, pick_ori='vector')
# Visualize it at the moment of peak activity.
_, time_max = stc.magnitude().get_peak(hemi='lh')
brain_mag = stc.plot(subjects_dir=subjects_dir, initial_time=time_max,
time_unit='s', size=(600, 400), overlay_alpha=0)
Explanation: When computing the source estimate, the activity at each of the three dipoles
is collapsed into the XYZ components of a single vector, which leads to the
following source estimate for the sample data:
End of explanation
# Set loose to 0.2, the default value
inv = make_inverse_operator(left_auditory.info, fwd, noise_cov, fixed=False,
loose=0.2)
stc = apply_inverse(left_auditory, inv, pick_ori='vector')
# Visualize it at the moment of peak activity.
_, time_max = stc.magnitude().get_peak(hemi='lh')
brain_loose = stc.plot(subjects_dir=subjects_dir, initial_time=time_max,
time_unit='s', size=(600, 400), overlay_alpha=0)
Explanation: Limiting orientations, but not fixing them
Often, the best results will be obtained by allowing the dipoles to have
somewhat free orientation, but not stray too far from a orientation that is
perpendicular to the cortex. The loose parameter of the
:func:mne.minimum_norm.make_inverse_operator allows you to specify a value
between 0 (fixed) and 1 (unrestricted or "free") to indicate the amount the
orientation is allowed to deviate from the surface normal.
End of explanation
# Only retain vector magnitudes
stc = apply_inverse(left_auditory, inv, pick_ori=None)
# Visualize it at the moment of peak activity.
_, time_max = stc.get_peak(hemi='lh')
brain = stc.plot(surface='white', subjects_dir=subjects_dir,
initial_time=time_max, time_unit='s', size=(600, 400))
Explanation: Discarding dipole orientation information
Often, further analysis of the data does not need information about the
orientation of the dipoles, but rather their magnitudes. The pick_ori
parameter of the :func:mne.minimum_norm.apply_inverse function allows you
to specify whether to return the full vector solution ('vector') or
rather the magnitude of the vectors (None, the default) or only the
activity in the direction perpendicular to the cortex ('normal').
End of explanation |
3,420 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<img style='float
Step1: Connect to server
Step2: <hr> Just connections
Circle plots show connections between nodes in a graph as lines between points around a circle. Let's make one for a set of random, sparse connections.
Step3: We can add a text label to each node. Here we'll just add a numeric identifier. Clicking on a node label highlights its connections -- try it!
Step4: <hr> Adding groups
Circle plots are useful for visualizing hierarchical relationships. You can specify multiple levels of grouping using a nested list. Let's start with one.
Step5: <hr> Nested groups
And now try adding a second level. We'll label by the second group to make clear what's going on. If you click on any of the outermost arcs, it will highlight connections to/from that group. | Python Code:
from lightning import Lightning
from numpy import random, asarray
Explanation: <img style='float: left' src="http://lightning-viz.github.io/images/logo.png"> <br> <br> Circle plots in <a href='http://lightning-viz.github.io/'><font color='#9175f0'>Lightning</font></a>
<hr> Setup
End of explanation
lgn = Lightning(ipython=True, host='http://public.lightning-viz.org')
Explanation: Connect to server
End of explanation
connections = random.rand(50,50)
connections[connections<0.98] = 0
lgn.circle(connections)
Explanation: <hr> Just connections
Circle plots show connections between nodes in a graph as lines between points around a circle. Let's make one for a set of random, sparse connections.
End of explanation
connections = random.rand(50,50)
connections[connections<0.98] = 0
lgn.circle(connections, labels=['node ' + str(x) for x in range(50)])
Explanation: We can add a text label to each node. Here we'll just add a numeric identifier. Clicking on a node label highlights its connections -- try it!
End of explanation
connections = random.rand(50,50)
connections[connections<0.98] = 0
group = (random.rand(50) * 3).astype('int')
lgn.circle(connections, labels=['group ' + str(x) for x in group], group=group)
Explanation: <hr> Adding groups
Circle plots are useful for visualizing hierarchical relationships. You can specify multiple levels of grouping using a nested list. Let's start with one.
End of explanation
connections = random.rand(50,50)
connections[connections<0.98] = 0
group1 = (random.rand(50) * 3).astype('int')
group2 = (random.rand(50) * 4).astype('int')
lgn.circle(connections, labels=['group ' + str(x) for x in group2], group=[group1, group2])
Explanation: <hr> Nested groups
And now try adding a second level. We'll label by the second group to make clear what's going on. If you click on any of the outermost arcs, it will highlight connections to/from that group.
End of explanation |
3,421 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Distribuciones de probabilidad con Python
Esta notebook fue creada originalmente como un blog post por Raúl E. López Briega en Matemáticas, análisis de datos y python. El contenido esta bajo la licencia BSD.
<img alt="Distribuciones estadísticas" title="Distribuciones estadísticas" src="https
Step1: Función de Masa de Probabilidad
Otra forma de representar a las distribuciones discretas es utilizando su Función de Masa de Probabilidad o FMP, la cual relaciona cada valor con su probabilidad en lugar de su frecuencia como vimos anteriormente. Esta función es normalizada de forma tal que el valor total de probabilidad sea 1. La ventaja que nos ofrece utilizar la FMP es que podemos comparar dos distribuciones sin necesidad de ser confundidos por las diferencias en el tamaño de las muestras. También debemos tener en cuenta que FMP funciona bien si el número de valores es pequeño; pero a medida que el número de valores aumenta, la probabilidad asociada a cada valor se hace cada vez más pequeña y el efecto del ruido aleatorio aumenta.
Veamos un ejemplo con Python.
Step2: Función de Distribución Acumulada
Si queremos evitar los problemas que se generan con FMP cuando el número de valores es muy grande, podemos recurrir a utilizar la Función de Distribución Acumulada o FDA, para representar a nuestras distribuciones, tanto discretas como continuas. Esta función relaciona los valores con su correspondiente percentil; es decir que va a describir la probabilidad de que una variable aleatoria X sujeta a cierta ley de distribución de probabilidad se sitúe en la zona de valores menores o iguales a x.
Step3: Función de Densidad de Probabilidad
Por último, el equivalente a la FMP para distribuciones continuas es la Función de Densidad de Probabilidad o FDP. Esta función es la derivada de la Función de Distribución Acumulada.
Por ejemplo, para la distribución normal que graficamos anteriormente, su FDP es la siguiente. La típica forma de campana que caracteriza a esta distribución.
Step4: Distribuciones
Ahora que ya conocemos como podemos hacer para representar a las distribuciones; pasemos a analizar cada una de ellas en más detalle para conocer su forma, sus principales aplicaciones y sus propiedades. Comencemos por las distribuciones discretas.
Distribuciones Discretas
Las distribuciones discretas son aquellas en las que la variable puede tomar solo algunos valores determinados. Los principales exponentes de este grupo son las siguientes
Step5: Distribución Binomial
La Distribución Binomial esta dada por la formula
Step6: Distribución Geométrica
La Distribución Geométrica esta dada por la formula
Step7: Distribución Hipergeométrica
La Distribución Hipergeométrica esta dada por la formula
Step8: Distribución de Bernoulli
La Distribución de Bernoulli esta dada por la formula
Step9: Distribuciones continuas
Ahora que ya conocemos las principales distribuciones discretas, podemos pasar a describir a las distribuciones continuas; en ellas a diferencia de lo que veíamos antes, la variable puede tomar cualquier valor dentro de un intervalo específico. Dentro de este grupo vamos a encontrar a las siguientes
Step10: Distribución Uniforme
La Distribución Uniforme es un caso muy simple expresada por la función
Step11: Distribución de Log-normal
La Distribución Log-normal esta dada por la formula
Step12: Distribución de Exponencial
La Distribución Exponencial esta dada por la formula
Step13: Distribución Gamma
La Distribución Gamma esta dada por la formula
Step14: Distribución Beta
La Distribución Beta esta dada por la formula
Step15: Distribución Chi cuadrado
La Distribución Chi cuadrado esta dada por la función
Step16: Distribución T de Student
La Distribución t de Student esta dada por la función
Step17: Distribución de Pareto
La Distribución de Pareto esta dada por la función | Python Code:
# <!-- collapse=True -->
# importando modulos necesarios
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from scipy import stats
import seaborn as sns
np.random.seed(2016) # replicar random
# parametros esteticos de seaborn
sns.set_palette("deep", desat=.6)
sns.set_context(rc={"figure.figsize": (8, 4)})
# Graficando histograma
mu, sigma = 0, 0.2 # media y desvio estandar
datos = np.random.normal(mu, sigma, 1000) #creando muestra de datos
# histograma de distribución normal.
cuenta, cajas, ignorar = plt.hist(datos, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma')
plt.show()
Explanation: Distribuciones de probabilidad con Python
Esta notebook fue creada originalmente como un blog post por Raúl E. López Briega en Matemáticas, análisis de datos y python. El contenido esta bajo la licencia BSD.
<img alt="Distribuciones estadísticas" title="Distribuciones estadísticas" src="https://relopezbriega.github.io/images/distribution.png" high=650px width=600px>
Introducción
Las variables aleatorias han llegado a desempeñar un papel importante en casi todos los campos de estudio: en la Física, la Química y la Ingeniería; y especialmente en las ciencias biológicas y sociales. Estas variables aleatorias son medidas y analizadas en términos
de sus propiedades estadísticas y probabilísticas, de las cuales una característica subyacente es su función de distribución. A pesar de que el número potencial de distribuciones puede ser muy grande, en la práctica, un número relativamente pequeño se utilizan; ya sea porque tienen características matemáticas que las hace fáciles de usar o porque se asemejan bastante bien a una porción de la realidad, o por ambas razones combinadas.
¿Por qué es importante conocer las distribuciones?
Muchos resultados en las ciencias se basan en conclusiones que se extraen sobre una población general a partir del estudio de una muestra de esta población. Este proceso se conoce como inferencia estadística; y este tipo de inferencia con frecuencia se basa en hacer suposiciones acerca de la forma en que los datos se distribuyen, o requiere realizar alguna transformación de los datos para que se ajusten mejor a alguna de las distribuciones conocidas y estudiadas en profundidad.
Las distribuciones de probabilidad teóricas son útiles en la inferencia estadística porque sus propiedades y características son conocidas. Si la distribución real de un conjunto de datos dado es razonablemente cercana a la de una distribución de probabilidad teórica, muchos de los cálculos se pueden realizar en los datos reales utilizando hipótesis extraídas de la distribución teórica.
Graficando distribuciones
Histogramas
Una de las mejores maneras de describir una variable es representar los valores que aparecen en el conjunto de datos y el número de veces que aparece cada valor. La representación más común de una distribución es un histograma, que es un gráfico que muestra la frecuencia de cada valor.
En Python, podemos graficar fácilmente un histograma con la ayuda de la función hist de matplotlib, simplemente debemos pasarle los datos y la cantidad de contenedores en los que queremos dividirlos. Por ejemplo, podríamos graficar el histograma de una distribución normal del siguiente modo.
End of explanation
# Graficando FMP
n, p = 30, 0.4 # parametros de forma de la distribución binomial
n_1, p_1 = 20, 0.3 # parametros de forma de la distribución binomial
x = np.arange(stats.binom.ppf(0.01, n, p),
stats.binom.ppf(0.99, n, p))
x_1 = np.arange(stats.binom.ppf(0.01, n_1, p_1),
stats.binom.ppf(0.99, n_1, p_1))
fmp = stats.binom.pmf(x, n, p) # Función de Masa de Probabilidad
fmp_1 = stats.binom.pmf(x_1, n_1, p_1) # Función de Masa de Probabilidad
plt.plot(x, fmp, '--')
plt.plot(x_1, fmp_1)
plt.vlines(x, 0, fmp, colors='b', lw=5, alpha=0.5)
plt.vlines(x_1, 0, fmp_1, colors='g', lw=5, alpha=0.5)
plt.title('Función de Masa de Probabilidad')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
Explanation: Función de Masa de Probabilidad
Otra forma de representar a las distribuciones discretas es utilizando su Función de Masa de Probabilidad o FMP, la cual relaciona cada valor con su probabilidad en lugar de su frecuencia como vimos anteriormente. Esta función es normalizada de forma tal que el valor total de probabilidad sea 1. La ventaja que nos ofrece utilizar la FMP es que podemos comparar dos distribuciones sin necesidad de ser confundidos por las diferencias en el tamaño de las muestras. También debemos tener en cuenta que FMP funciona bien si el número de valores es pequeño; pero a medida que el número de valores aumenta, la probabilidad asociada a cada valor se hace cada vez más pequeña y el efecto del ruido aleatorio aumenta.
Veamos un ejemplo con Python.
End of explanation
# Graficando Función de Distribución Acumulada con Python
x_1 = np.linspace(stats.norm(10, 1.2).ppf(0.01),
stats.norm(10, 1.2).ppf(0.99), 100)
fda_binom = stats.binom.cdf(x, n, p) # Función de Distribución Acumulada
fda_normal = stats.norm(10, 1.2).cdf(x_1) # Función de Distribución Acumulada
plt.plot(x, fda_binom, '--', label='FDA binomial')
plt.plot(x_1, fda_normal, label='FDA nomal')
plt.title('Función de Distribución Acumulada')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.legend(loc=4)
plt.show()
Explanation: Función de Distribución Acumulada
Si queremos evitar los problemas que se generan con FMP cuando el número de valores es muy grande, podemos recurrir a utilizar la Función de Distribución Acumulada o FDA, para representar a nuestras distribuciones, tanto discretas como continuas. Esta función relaciona los valores con su correspondiente percentil; es decir que va a describir la probabilidad de que una variable aleatoria X sujeta a cierta ley de distribución de probabilidad se sitúe en la zona de valores menores o iguales a x.
End of explanation
# Graficando Función de Densidad de Probibilidad con Python
FDP_normal = stats.norm(10, 1.2).pdf(x_1) # FDP
plt.plot(x_1, FDP_normal, label='FDP nomal')
plt.title('Función de Densidad de Probabilidad')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
Explanation: Función de Densidad de Probabilidad
Por último, el equivalente a la FMP para distribuciones continuas es la Función de Densidad de Probabilidad o FDP. Esta función es la derivada de la Función de Distribución Acumulada.
Por ejemplo, para la distribución normal que graficamos anteriormente, su FDP es la siguiente. La típica forma de campana que caracteriza a esta distribución.
End of explanation
# Graficando Poisson
mu = 3.6 # parametro de forma
poisson = stats.poisson(mu) # Distribución
x = np.arange(poisson.ppf(0.01),
poisson.ppf(0.99))
fmp = poisson.pmf(x) # Función de Masa de Probabilidad
plt.plot(x, fmp, '--')
plt.vlines(x, 0, fmp, colors='b', lw=5, alpha=0.5)
plt.title('Distribución Poisson')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = poisson.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Poisson')
plt.show()
Explanation: Distribuciones
Ahora que ya conocemos como podemos hacer para representar a las distribuciones; pasemos a analizar cada una de ellas en más detalle para conocer su forma, sus principales aplicaciones y sus propiedades. Comencemos por las distribuciones discretas.
Distribuciones Discretas
Las distribuciones discretas son aquellas en las que la variable puede tomar solo algunos valores determinados. Los principales exponentes de este grupo son las siguientes:
Distribución Poisson
La Distribución Poisson esta dada por la formula:
$$p(r; \mu) = \frac{\mu^r e^{-\mu}}{r!}$$
En dónde $r$ es un entero ($r \ge 0$) y $\mu$ es un número real positivo. La Distribución Poisson describe la probabilidad de encontrar exactamente $r$ eventos en un lapso de tiempo si los acontecimientos se producen de forma independiente a una velocidad constante $\mu$. Es una de las distribuciones más utilizadas en estadística con varias aplicaciones; como por ejemplo describir el número de fallos en un lote de materiales o la cantidad de llegadas por hora a un centro de servicios.
En Python la podemos generar fácilmente con la ayuda de scipy.stats, paquete que utilizaremos para representar a todas las restantes distribuciones a lo largo de todo el artículo.
End of explanation
# Graficando Binomial
N, p = 30, 0.4 # parametros de forma
binomial = stats.binom(N, p) # Distribución
x = np.arange(binomial.ppf(0.01),
binomial.ppf(0.99))
fmp = binomial.pmf(x) # Función de Masa de Probabilidad
plt.plot(x, fmp, '--')
plt.vlines(x, 0, fmp, colors='b', lw=5, alpha=0.5)
plt.title('Distribución Binomial')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = binomial.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Binomial')
plt.show()
Explanation: Distribución Binomial
La Distribución Binomial esta dada por la formula:
$$p(r; N, p) = \left(\begin{array}{c} N \ r \end{array}\right) p^r(1 - p)^{N - r}
$$
En dónde $r$ con la condición $0 \le r \le N$ y el parámetro $N$ ($N > 0$) son enteros; y el parámetro $p$ ($0 \le p \le 1$) es un número real. La Distribución Binomial describe la probabilidad de exactamente $r$ éxitos en $N$ pruebas si la probabilidad de éxito en una sola prueba es $p$.
End of explanation
# Graficando Geométrica
p = 0.3 # parametro de forma
geometrica = stats.geom(p) # Distribución
x = np.arange(geometrica.ppf(0.01),
geometrica.ppf(0.99))
fmp = geometrica.pmf(x) # Función de Masa de Probabilidad
plt.plot(x, fmp, '--')
plt.vlines(x, 0, fmp, colors='b', lw=5, alpha=0.5)
plt.title('Distribución Geométrica')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = geometrica.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Geométrica')
plt.show()
Explanation: Distribución Geométrica
La Distribución Geométrica esta dada por la formula:
$$p(r; p) = p(1- p)^{r-1}
$$
En dónde $r \ge 1$ y el parámetro $p$ ($0 \le p \le 1$) es un número real. La Distribución Geométrica expresa la probabilidad de tener que esperar exactamente $r$ pruebas hasta encontrar el primer éxito si la probabilidad de éxito en una sola prueba es $p$. Por ejemplo, en un proceso de selección, podría definir el número de entrevistas que deberíamos realizar antes de encontrar al primer candidato aceptable.
End of explanation
# Graficando Hipergeométrica
M, n, N = 30, 10, 12 # parametros de forma
hipergeometrica = stats.hypergeom(M, n, N) # Distribución
x = np.arange(0, n+1)
fmp = hipergeometrica.pmf(x) # Función de Masa de Probabilidad
plt.plot(x, fmp, '--')
plt.vlines(x, 0, fmp, colors='b', lw=5, alpha=0.5)
plt.title('Distribución Hipergeométrica')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = hipergeometrica.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Hipergeométrica')
plt.show()
Explanation: Distribución Hipergeométrica
La Distribución Hipergeométrica esta dada por la formula:
$$p(r; n, N, M) = \frac{\left(\begin{array}{c} M \ r \end{array}\right)\left(\begin{array}{c} N - M\ n -r \end{array}\right)}{\left(\begin{array}{c} N \ n \end{array}\right)}
$$
En dónde el valor de $r$ esta limitado por $\max(0, n - N + M)$ y $\min(n, M)$ inclusive; y los parámetros $n$ ($1 \le n \le N$), $N$ ($N \ge 1$) y $M$ ($M \ge 1$) son todos números enteros. La Distribución Hipergeométrica describe experimentos en donde se seleccionan los elementos al azar sin reemplazo (se evita seleccionar el mismo elemento más de una vez). Más precisamente, supongamos que tenemos $N$ elementos de los cuales $M$ tienen un cierto atributo (y $N - M$ no tiene). Si escogemos $n$ elementos al azar sin reemplazo, $p(r)$ es la probabilidad de que exactamente $r$ de los elementos seleccionados provienen del grupo con el atributo.
End of explanation
# Graficando Bernoulli
p = 0.5 # parametro de forma
bernoulli = stats.bernoulli(p)
x = np.arange(-1, 3)
fmp = bernoulli.pmf(x) # Función de Masa de Probabilidad
fig, ax = plt.subplots()
ax.plot(x, fmp, 'bo')
ax.vlines(x, 0, fmp, colors='b', lw=5, alpha=0.5)
ax.set_yticks([0., 0.2, 0.4, 0.6])
plt.title('Distribución Bernoulli')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = bernoulli.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Bernoulli')
plt.show()
Explanation: Distribución de Bernoulli
La Distribución de Bernoulli esta dada por la formula:
$$p(r;p) = \left{
\begin{array}{ll}
1 - p = q & \mbox{si } r = 0 \ \mbox{(fracaso)}\
p & \mbox{si } r = 1 \ \mbox{(éxito)}
\end{array}
\right.$$
En dónde el parámetro $p$ es la probabilidad de éxito en un solo ensayo, la probabilidad de fracaso por lo tanto va a ser $1 - p$ (muchas veces expresada como $q$). Tanto $p$ como $q$ van a estar limitados al intervalo de cero a uno. La Distribución de Bernoulli describe un experimento probabilístico en donde el ensayo tiene dos posibles resultados, éxito o fracaso. Desde esta distribución se pueden deducir varias Funciones de Densidad de Probabilidad de otras distribuciones que se basen en una serie de ensayos independientes.
End of explanation
# Graficando Normal
mu, sigma = 0, 0.2 # media y desvio estandar
normal = stats.norm(mu, sigma)
x = np.linspace(normal.ppf(0.01),
normal.ppf(0.99), 100)
fp = normal.pdf(x) # Función de Probabilidad
plt.plot(x, fp)
plt.title('Distribución Normal')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = normal.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Normal')
plt.show()
Explanation: Distribuciones continuas
Ahora que ya conocemos las principales distribuciones discretas, podemos pasar a describir a las distribuciones continuas; en ellas a diferencia de lo que veíamos antes, la variable puede tomar cualquier valor dentro de un intervalo específico. Dentro de este grupo vamos a encontrar a las siguientes:
Distribución de Normal
La Distribución Normal, o también llamada Distribución de Gauss, es aplicable a un amplio rango de problemas, lo que la convierte en la distribución más utilizada en estadística; esta dada por la formula:
$$p(x;\mu, \sigma^2) = \frac{1}{\sigma \sqrt{2 \pi}} e^{\frac{-1}{2}\left(\frac{x - \mu}{\sigma} \right)^2}
$$
En dónde $\mu$ es el parámetro de ubicación, y va a ser igual a la media aritmética y $\sigma^2$ es el desvío estándar. Algunos ejemplos de variables asociadas a fenómenos naturales que siguen el modelo de la Distribución Normal son:
* características morfológicas de individuos, como la estatura;
* características sociológicas, como el consumo de cierto producto por un mismo grupo de individuos;
* características psicológicas, como el cociente intelectual;
* nivel de ruido en telecomunicaciones;
* errores cometidos al medir ciertas magnitudes;
* etc.
End of explanation
# Graficando Uniforme
uniforme = stats.uniform()
x = np.linspace(uniforme.ppf(0.01),
uniforme.ppf(0.99), 100)
fp = uniforme.pdf(x) # Función de Probabilidad
fig, ax = plt.subplots()
ax.plot(x, fp, '--')
ax.vlines(x, 0, fp, colors='b', lw=5, alpha=0.5)
ax.set_yticks([0., 0.2, 0.4, 0.6, 0.8, 1., 1.2])
plt.title('Distribución Uniforme')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = uniforme.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Uniforme')
plt.show()
Explanation: Distribución Uniforme
La Distribución Uniforme es un caso muy simple expresada por la función:
$$f(x; a, b) = \frac{1}{b -a} \ \mbox{para} \ a \le x \le b
$$
Su función de distribución esta entonces dada por:
$$
p(x;a, b) = \left{
\begin{array}{ll}
0 & \mbox{si } x \le a \
\frac{x-a}{b-a} & \mbox{si } a \le x \le b \
1 & \mbox{si } b \le x
\end{array}
\right.
$$
Todos los valore tienen prácticamente la misma probabilidad.
End of explanation
# Graficando Log-Normal
sigma = 0.6 # parametro
lognormal = stats.lognorm(sigma)
x = np.linspace(lognormal.ppf(0.01),
lognormal.ppf(0.99), 100)
fp = lognormal.pdf(x) # Función de Probabilidad
plt.plot(x, fp)
plt.title('Distribución Log-normal')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = lognormal.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Log-normal')
plt.show()
Explanation: Distribución de Log-normal
La Distribución Log-normal esta dada por la formula:
$$p(x;\mu, \sigma) = \frac{1}{ x \sigma \sqrt{2 \pi}} e^{\frac{-1}{2}\left(\frac{\ln x - \mu}{\sigma} \right)^2}
$$
En dónde la variable $x > 0$ y los parámetros $\mu$ y $\sigma > 0$ son todos números reales. La Distribución Log-normal es aplicable a variables aleatorias que están limitadas por cero, pero tienen pocos valores grandes. Es una distribución con asimetría positiva. Algunos de los ejemplos en que la solemos encontrar son:
* El peso de los adultos.
* La concentración de los minerales en depósitos.
* Duración de licencia por enfermedad.
* Distribución de riqueza
* Tiempos muertos de maquinarias.
End of explanation
# Graficando Exponencial
exponencial = stats.expon()
x = np.linspace(exponencial.ppf(0.01),
exponencial.ppf(0.99), 100)
fp = exponencial.pdf(x) # Función de Probabilidad
plt.plot(x, fp)
plt.title('Distribución Exponencial')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = exponencial.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Exponencial')
plt.show()
Explanation: Distribución de Exponencial
La Distribución Exponencial esta dada por la formula:
$$p(x;\alpha) = \frac{1}{ \alpha} e^{\frac{-x}{\alpha}}
$$
En dónde tanto la variable $x$ como el parámetro $\alpha$ son números reales positivos. La Distribución Exponencial tiene bastantes aplicaciones, tales como la desintegración de un átomo radioactivo o el tiempo entre eventos en un proceso de Poisson donde los acontecimientos suceden a una velocidad constante.
End of explanation
# Graficando Gamma
a = 2.6 # parametro de forma.
gamma = stats.gamma(a)
x = np.linspace(gamma.ppf(0.01),
gamma.ppf(0.99), 100)
fp = gamma.pdf(x) # Función de Probabilidad
plt.plot(x, fp)
plt.title('Distribución Gamma')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = gamma.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Gamma')
plt.show()
Explanation: Distribución Gamma
La Distribución Gamma esta dada por la formula:
$$p(x;a, b) = \frac{a(a x)^{b -1} e^{-ax}}{\Gamma(b)}
$$
En dónde los parámetros $a$ y $b$ y la variable $x$ son números reales positivos y $\Gamma(b)$ es la función gamma. La Distribución Gamma comienza en el origen de coordenadas y tiene una forma bastante flexible. Otras distribuciones son casos especiales de ella.
End of explanation
# Graficando Beta
a, b = 2.3, 0.6 # parametros de forma.
beta = stats.beta(a, b)
x = np.linspace(beta.ppf(0.01),
beta.ppf(0.99), 100)
fp = beta.pdf(x) # Función de Probabilidad
plt.plot(x, fp)
plt.title('Distribución Beta')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = beta.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Beta')
plt.show()
Explanation: Distribución Beta
La Distribución Beta esta dada por la formula:
$$p(x;p, q) = \frac{1}{B(p, q)} x^{p-1}(1 - x)^{q-1}
$$
En dónde los parámetros $p$ y $q$ son números reales positivos, la variable $x$ satisface la condición $0 \le x \le 1$ y $B(p, q)$ es la función beta. Las aplicaciones de la Distribución Beta incluyen el modelado de variables aleatorias que tienen un rango finito de $a$ hasta $b$. Un
ejemplo de ello es la distribución de los tiempos de actividad en las redes de proyectos. La Distribución Beta se utiliza también con frecuencia como una probabilidad a priori para proporciones [binomiales]((https://es.wikipedia.org/wiki/Distribuci%C3%B3n_binomial) en el análisis bayesiano.
End of explanation
# Graficando Chi cuadrado
df = 34 # parametro de forma.
chi2 = stats.chi2(df)
x = np.linspace(chi2.ppf(0.01),
chi2.ppf(0.99), 100)
fp = chi2.pdf(x) # Función de Probabilidad
plt.plot(x, fp)
plt.title('Distribución Chi cuadrado')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = chi2.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma Chi cuadrado')
plt.show()
Explanation: Distribución Chi cuadrado
La Distribución Chi cuadrado esta dada por la función:
$$p(x; n) = \frac{\left(\frac{x}{2}\right)^{\frac{n}{2}-1} e^{\frac{-x}{2}}}{2\Gamma \left(\frac{n}{2}\right)}
$$
En dónde la variable $x \ge 0$ y el parámetro $n$, el número de grados de libertad, es un número entero positivo. Una importante aplicación de la Distribución Chi cuadrado es que cuando un conjunto de datos es representado por un modelo teórico, esta distribución puede ser utilizada para controlar cuan bien se ajustan los valores predichos por el modelo, y los datos realmente observados.
End of explanation
# Graficando t de Student
df = 50 # parametro de forma.
t = stats.t(df)
x = np.linspace(t.ppf(0.01),
t.ppf(0.99), 100)
fp = t.pdf(x) # Función de Probabilidad
plt.plot(x, fp)
plt.title('Distribución t de Student')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = t.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma t de Student')
plt.show()
Explanation: Distribución T de Student
La Distribución t de Student esta dada por la función:
$$p(t; n) = \frac{\Gamma(\frac{n+1}{2})}{\sqrt{n\pi}\Gamma(\frac{n}{2})} \left( 1 + \frac{t^2}{2} \right)^{-\frac{n+1}{2}}
$$
En dónde la variable $t$ es un número real y el parámetro $n$ es un número entero positivo. La Distribución t de Student es utilizada para probar si la diferencia entre las medias de dos muestras de observaciones es estadísticamente significativa. Por ejemplo, las alturas de una muestra aleatoria de los jugadores de baloncesto podría compararse con las alturas de una muestra aleatoria de jugadores de fútbol; esta distribución nos podría ayudar a determinar si un grupo es significativamente más alto que el otro.
End of explanation
# Graficando Pareto
k = 2.3 # parametro de forma.
pareto = stats.pareto(k)
x = np.linspace(pareto.ppf(0.01),
pareto.ppf(0.99), 100)
fp = pareto.pdf(x) # Función de Probabilidad
plt.plot(x, fp)
plt.title('Distribución de Pareto')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
# histograma
aleatorios = pareto.rvs(1000) # genera aleatorios
cuenta, cajas, ignorar = plt.hist(aleatorios, 20)
plt.ylabel('frequencia')
plt.xlabel('valores')
plt.title('Histograma de Pareto')
plt.show()
Explanation: Distribución de Pareto
La Distribución de Pareto esta dada por la función:
$$p(x; \alpha, k) = \frac{\alpha k^{\alpha}}{x^{\alpha + 1}}
$$
En dónde la variable $x \ge k$ y el parámetro $\alpha > 0$ son números reales. Esta distribución fue introducida por su inventor, Vilfredo Pareto, con el fin de explicar la distribución de los salarios en la sociedad. La Distribución de Pareto se describe a menudo como la base de la regla 80/20. Por ejemplo, el 80% de las quejas de los clientes con respecto al funcionamiento de su vehículo por lo general surgen del 20% de los componentes.
End of explanation |
3,422 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Disaggregation experiments
Customary imports
Step1: show versions for any diagnostics
Step2: Load dataset
Step3: Let us perform our analysis on selected 2 days
Step4: Training
We'll now do the training from the aggregate data. The algorithm segments the time series data into steady and transient states. Thus, we'll first figure out the transient and the steady states. Next, we'll try and pair the on and the off transitions based on their proximity in time and value. | Python Code:
import numpy as np
import pandas as pd
from os.path import join
from pylab import rcParams
import matplotlib.pyplot as plt
%matplotlib inline
#rcParams['figure.figsize'] = (12, 6)
rcParams['figure.figsize'] = (13, 6)
plt.style.use('ggplot')
import nilmtk
from nilmtk import DataSet, TimeFrame, MeterGroup, HDFDataStore
from nilmtk.disaggregate import CombinatorialOptimisation
from nilmtk.utils import print_dict, show_versions
from nilmtk.metrics import f1_score
#import seaborn as sns
#sns.set_palette("Set3", n_colors=12)
import warnings
warnings.filterwarnings("ignore")
Explanation: Disaggregation experiments
Customary imports
End of explanation
show_versions()
Explanation: show versions for any diagnostics
End of explanation
data_dir = '/Users/GJWood/nilm_gjw_data/HDF5/'
gjw = DataSet(join(data_dir, 'nilm_gjw_data.hdf5'))
print('loaded ' + str(len(gjw.buildings)) + ' buildings')
building_number=1
Explanation: Load dataset
End of explanation
gjw.store.window = TimeFrame(start='2013-12-03 00:00:00', end='2013-12-05 00:00:00')
elec = gjw.buildings[building_number].elec
mains = elec.mains()
house = elec['fridge'] #only one meter so any selection will do
df = house.load().next() #load the first chunk of data into a dataframe
df.info() #check that the data is what we want (optional)
#note the data has two columns and a time index
df.head()
df.tail()
df.plot()
Explanation: Let us perform our analysis on selected 2 days
End of explanation
df.ix['2013-12-03 11:00:00':'2013-12-03 12:00:00'].plot()# select a time range and plot it
from nilmtk.disaggregate.hart_85 import Hart85
h = Hart85()
h.train(mains,cols=[('power','apparent'),('power','reactive')])
from nilmtk.disaggregate.hart_85 import Hart85
h = Hart85()
h.train(mains,cols=[('power','apparent')])
Explanation: Training
We'll now do the training from the aggregate data. The algorithm segments the time series data into steady and transient states. Thus, we'll first figure out the transient and the steady states. Next, we'll try and pair the on and the off transitions based on their proximity in time and value.
End of explanation |
3,423 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Python Record IO
In image_io we already learned how to pack image into standard recordio format and load it with ImageRecordIter. This tutorial will walk through the python interface for reading and writing record io files. It can be useful when you need more more control over the details of data pipeline. For example, when you need to augument image and label together for detection and segmentation, or when you need a custom data iterator for triplet sampling and negative sampling.
Setup environment first
Step1: The relevent code is under mx.recordio. There are two classes
Step2: Then we can read it back by opening the same file with 'r'
Step3: MXIndexedRecordIO
Some times you need random access for more complex tasks. MXIndexedRecordIO is designed for this. Here we create a indexed record tmp.rec and a corresponding index file tmp.idx
Step4: We can then access records with keys
Step5: You can list all keys with
Step6: Packing and Unpacking Data
Each record in a .rec file can contain arbitrary binary data, but machine learning data typically has a label/data structure. mx.recordio also contains a few utility functions for packing such data, namely
Step7: Image Data
pack_img and unpack_img are used for packing image data. Records packed by pack_img can be loaded by mx.io.ImageRecordIter. | Python Code:
%matplotlib inline
from __future__ import print_function
import mxnet as mx
import numpy as np
import matplotlib.pyplot as plt
Explanation: Python Record IO
In image_io we already learned how to pack image into standard recordio format and load it with ImageRecordIter. This tutorial will walk through the python interface for reading and writing record io files. It can be useful when you need more more control over the details of data pipeline. For example, when you need to augument image and label together for detection and segmentation, or when you need a custom data iterator for triplet sampling and negative sampling.
Setup environment first:
End of explanation
record = mx.recordio.MXRecordIO('tmp.rec', 'w')
for i in range(5):
record.write('record_%d'%i)
record.close()
Explanation: The relevent code is under mx.recordio. There are two classes: MXRecordIO, which supports sequential read and write, and MXIndexedRecordIO, which supports random read and sequential write.
MXRecordIO
First let's take a look at MXRecordIO. We open a file tmp.rec and write 5 strings to it:
End of explanation
record = mx.recordio.MXRecordIO('tmp.rec', 'r')
while True:
item = record.read()
if not item:
break
print(item)
record.close()
Explanation: Then we can read it back by opening the same file with 'r':
End of explanation
record = mx.recordio.MXIndexedRecordIO('tmp.idx', 'tmp.rec', 'w')
for i in range(5):
record.write_idx(i, 'record_%d'%i)
record.close()
Explanation: MXIndexedRecordIO
Some times you need random access for more complex tasks. MXIndexedRecordIO is designed for this. Here we create a indexed record tmp.rec and a corresponding index file tmp.idx:
End of explanation
record = mx.recordio.MXIndexedRecordIO('tmp.idx', 'tmp.rec', 'r')
record.read_idx(3)
Explanation: We can then access records with keys:
End of explanation
record.keys
Explanation: You can list all keys with:
End of explanation
# pack
data = 'data'
label1 = 1.0
header1 = mx.recordio.IRHeader(flag=0, label=label1, id=1, id2=0)
s1 = mx.recordio.pack(header1, data)
print('float label:', repr(s1))
label2 = [1.0, 2.0, 3.0]
header2 = mx.recordio.IRHeader(flag=0, label=label2, id=2, id2=0)
s2 = mx.recordio.pack(header2, data)
print('array label:', repr(s2))
# unpack
print(*mx.recordio.unpack(s1))
print(*mx.recordio.unpack(s2))
Explanation: Packing and Unpacking Data
Each record in a .rec file can contain arbitrary binary data, but machine learning data typically has a label/data structure. mx.recordio also contains a few utility functions for packing such data, namely: pack, unpack, pack_img, and unpack_img.
Binary Data
pack and unpack are used for storing float (or 1d array of float) label and binary data:
End of explanation
# pack_img
data = np.ones((3,3,1), dtype=np.uint8)
label = 1.0
header = mx.recordio.IRHeader(flag=0, label=label, id=0, id2=0)
s = mx.recordio.pack_img(header, data, quality=100, img_fmt='.jpg')
print(repr(s))
# unpack_img
print(*mx.recordio.unpack_img(s))
Explanation: Image Data
pack_img and unpack_img are used for packing image data. Records packed by pack_img can be loaded by mx.io.ImageRecordIter.
End of explanation |
3,424 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
What is pytorch?
gpu 성능을 사용하기 위해 numpy를 대체
최대한 유연성과 속도를 제공하는 딥러닝 연구 플랫폼
Tensors
numpy의 ndarrays와 유사
GPU 파워를 사용할 수 있음
Step1: x.copy_(y), x.t_()는 x가 변경되는 연산
Step2: 기타 연산 자료
Step3: CharTensor를 제외하고 CPU상의 모든 텐서는 numpy로 변환하는 것을 지원
Step4: tensor들은 .cuda function을 사용해 gpu로 옮길 수 있음
Step5: Autograd
Step6: Autograd / Function 문서
Neural Networks
torch.nn 패키지에 작성되어 있음
nn.module은 레이러를 포함하고 forward(input) 메서드가 있고 output을 return
Step7: Define the neural network that has some learnable parameters (or weights)
Iterate over a dataset of inputs
Process input through the network
Compute the loss (how far is the output from being correct)
Propagate gradients back into the network’s parameters
Update the weights of the network, typically using a simple update rule | Python Code:
import torch
x = torch.Tensor(5, 3)
print(x)
len(x)
x.shape
y = torch.rand(5,3)
print(y)
print(x + y)
print(torch.add(x, y))
result = torch.Tensor(5, 3)
print(result)
torch.add(x, y, out=result)
print(result)
print('before y:', y)
y.add_(x)
print('after y:', y)
x.t_()
Explanation: What is pytorch?
gpu 성능을 사용하기 위해 numpy를 대체
최대한 유연성과 속도를 제공하는 딥러닝 연구 플랫폼
Tensors
numpy의 ndarrays와 유사
GPU 파워를 사용할 수 있음
End of explanation
# numpy 스럽게 사용 가능
print(x[:, 1])
print(x[:,:])
Explanation: x.copy_(y), x.t_()는 x가 변경되는 연산
End of explanation
a = torch.ones(5)
print(a)
b = a.numpy()
print(b)
a.add_(1)
print(a)
print(b)
# a와 b가 연결되어 있음
print(b)
a.add_(2)
print(b)
id(a)
id(b)
import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b)
Explanation: 기타 연산 자료
End of explanation
%%time
if torch.cuda.is_available():
x = x.cuda()
y = y.cuda()
x + y
Explanation: CharTensor를 제외하고 CPU상의 모든 텐서는 numpy로 변환하는 것을 지원
End of explanation
torch.cuda.is_available()
torch.cuda.current_device()
torch.cuda.device_count()
Explanation: tensor들은 .cuda function을 사용해 gpu로 옮길 수 있음
End of explanation
import torch
from torch.autograd import Variable
x = Variable(torch.ones(2, 2), requires_grad=True)
print(x)
y = x + 2
print(y)
print(y.grad_fn)
# y는 연산의 결과라서 grad_fn이 잇음
z = y * y * 3
out = z.mean()
print(z, out)
print(x.grad)
out.backward()
print(x.grad)
x = torch.randn(3)
x = Variable(x, requires_grad=True)
y = x * 2
while y.data.norm() < 1000:
y = y * 2
print(y)
gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)
print(x.grad)
Explanation: Autograd : autumatic differentiation
autograd.Variable. 텐서로 랩핑되어 있음
.backward() API를 콜하기만 하면 모든 그라디언트 연산을 자동으로 해줌
Function은 상호연결되어 있어서 비순환 그래프를 만듬.
End of explanation
dtype = torch.FloatTensor
N, D_in, H, D_out = 64, 1000, 100, 10
Explanation: Autograd / Function 문서
Neural Networks
torch.nn 패키지에 작성되어 있음
nn.module은 레이러를 포함하고 forward(input) 메서드가 있고 output을 return
End of explanation
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) # 2x2 windown max pooling
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
size = x.size()[1:]
num_features = 1
for s in size:
num_features *= s
return num_features
net = Net()
print(net)
params = list(net.parameters())
print(len(params))
print(params[0].size())
input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
print(out)
net.zero_grad()
out.backward(torch.randn(1, 10))
output = net(input)
target = Variable(torch.arange(1, 11)) # a dummy target, for example
criterion = nn.MSELoss()
loss = criterion(output, target)
print(loss)
print(loss.grad_fn) # MSELoss
print(loss.grad_fn.next_functions[0][0]) # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0]) # ReLU
net.zero_grad() # zeroes the gradient buffers of all parameters
print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)
loss.backward()
print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)
learning_rate = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * learning_rate)
import torch.optim as optim
# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)
# in your training loop:
optimizer.zero_grad() # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Does the update
import torch
import torchvision
import torchvision.transforms as transforms
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
import matplotlib.pyplot as plt
import numpy as np
# functions to show an image
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()
# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs
inputs, labels = data
# wrap them in Variable
# inputs, labels = Variable(inputs), Variable(labels)
inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.data[0]
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
# imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
outputs = net(Variable(images))
_, predicted = torch.max(outputs.data, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
correct = 0
total = 0
for data in testloader:
images, labels = data
outputs = net(Variable(images))
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
for data in testloader:
images, labels = data
outputs = net(Variable(images))
_, predicted = torch.max(outputs.data, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i]
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
Explanation: Define the neural network that has some learnable parameters (or weights)
Iterate over a dataset of inputs
Process input through the network
Compute the loss (how far is the output from being correct)
Propagate gradients back into the network’s parameters
Update the weights of the network, typically using a simple update rule:
weight = weight - learning_rate * gradient
End of explanation |
3,425 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<h1><center>[Notebooks](../) - [Access to Geospatial data](../Access to Geospatial data)</center></h1>
OSSIM Command Line Applications
The following command line applications are distributed with OSSIM.
Core Programs
ossim-info Used to run ossim utilities function and to display metadata for imagery, maps, terrain, and vector data.
Utility functions
radians from degrees
degrees from radians
meters from feet
meters to feet
Meters per degree
height
Projections
Datums
Explore raster data
ground center
image center
ground and image center
general image information
meta data image information
image projection information
image rectangle
Utilities to Create Support Files
The following tools are used to create OSSIM support files
Step1: Set the PATH to the natural earth dataset used in this notebook
Step2: ossim-info
top
Step3: Utility functions
radians from degrees
ossim-info --deg2rad <degrees>
Step4: top
degrees from radians
ossim-info --rad2deg <radians>
Step5: top
meters from feet
0.3048 meters per foot
ossim-info --ft2mtrs <feet>
Step6: 0.3048006096 meters per foot
ossim-info --ft2mtrs-us-survey <feet>
Step7: top
meters to feet
0.3048 meters per foot
ossim-info --mtrs2ft <meters>
Step8: 0.3048006096 meters per foot
ossim-info --mtrs2ft-us-survey <meters>
Step9: top
height
return the MSL and ellipoid height given a latitude longitude position
ossim-info --height <latitude-in-degrees> <longitude-in-degrees>
Step10: top
Meters per degrees
Gives meters per degree and meters per minute for a given latitude.
ossim-info --mtrsPerDeg <latitude>
Step11: top
Datums
Prints datum list.
ossim-info --datums
Step12: Projections
Prints projections list
ossim-info --projections
Step13: top
Explore raster data
ground center
```ossim-info --cg filename```
Step14: top
image center
```ossim-info --ci filename```
Step15: top
ground and image center
```ossim-info -c filename```
Step16: top
general image information
```ossim-info -i filename```
Step17: top
meta data image information
ossim-info -m filename
Step18: top
image projection information
ossim-info -p filename
Step19: top
image rectangle
ossim-info -r filename
Step20: top
ossim-img2rr
Step21: ossim-cmm
Step22: ossim-img2md
Usage
Step23: ossim-band-merge
ossim-band-merge [-h][-o][-w tile_width] <output_type> <input_file1> <input_file2> ... <output_file>
Example, crete an RGB image from the single-band grayscale r,g,b images (Landsat 7)
Step24: top
ossim-create-histo
Step25: ossim-chipper
Step26: top
ossim-icp
ossim-icp [options] <output_type> <input_file> <output_file>
Step27: top
ossim-igen
Execute image chains specified in a spec file.
In the folowing example the spec file rgb.spec has been generated using imagelinker, from an example session | Python Code:
from IPython.core.display import Image
Explanation: <h1><center>[Notebooks](../) - [Access to Geospatial data](../Access to Geospatial data)</center></h1>
OSSIM Command Line Applications
The following command line applications are distributed with OSSIM.
Core Programs
ossim-info Used to run ossim utilities function and to display metadata for imagery, maps, terrain, and vector data.
Utility functions
radians from degrees
degrees from radians
meters from feet
meters to feet
Meters per degree
height
Projections
Datums
Explore raster data
ground center
image center
ground and image center
general image information
meta data image information
image projection information
image rectangle
Utilities to Create Support Files
The following tools are used to create OSSIM support files:
ossim-img2rr Create reduced resolution data sets for an image.
ossim-cmm Determine the min/max pixel values of an image.
ossim-create-histo Compute a histogram for an image.
ossim-img2md Create meta data files.
ossim-tfw2ogeom Create a geom file from a TIFF World File.
ossim-extract-vertices Compute the valid vertices (corners) of an image.
ossim-preproc Create reduced resolution data sets, histograms, and so on. Application does directory walking and is threaded at a file level.
ossim-applanix2ogeom Create a geom file for Applanix Images.
ossim-create-cg Create an ossim coarse grid.
ossim-ecg2ocg Convert an enhanced coarse grid to an ossim coarse grid.
OSSIM-Applications
ossim-band-merge Merge multiple image files into a single n-band dataset.
ossim-chipper Render elevation data (e.g. shaded relief).
ossim-icp Convert an image from one format to another.
ossim-igen Execute image chains specified in a spec file.
ossim-orthoigen Tool to orthorectify, mosaic, and convert raster data between different formats. It provides a number of operations including subsetting, resampling, histogram matching, and reprojection of data.
ossim-rpf Various utilities for managing RPF data.
Import IPython utility to display images
End of explanation
DATADIR='/home/main/notebooks/data/landsat/'
# we'll use the north_carolina image dataset
!ls {DATADIR} | grep tif
Explanation: Set the PATH to the natural earth dataset used in this notebook
End of explanation
!ossim-info
Explanation: ossim-info
top
End of explanation
!ossim-info --deg2rad 20.54
Explanation: Utility functions
radians from degrees
ossim-info --deg2rad <degrees>
End of explanation
!ossim-info --rad2deg 0.35849
Explanation: top
degrees from radians
ossim-info --rad2deg <radians>
End of explanation
!ossim-info --ft2mtrs 1
Explanation: top
meters from feet
0.3048 meters per foot
ossim-info --ft2mtrs <feet>
End of explanation
!ossim-info --ft2mtrs-us-survey 1
Explanation: 0.3048006096 meters per foot
ossim-info --ft2mtrs-us-survey <feet>
End of explanation
!ossim-info --mtrs2ft 1
Explanation: top
meters to feet
0.3048 meters per foot
ossim-info --mtrs2ft <meters>
End of explanation
!ossim-info --mtrs2ft-us-survey 1
Explanation: 0.3048006096 meters per foot
ossim-info --mtrs2ft-us-survey <meters>
End of explanation
# note we pass the path to the ossim_preference file to tell where the geoid file is
!ossim-info --height 47.54 157.40 -P /usr/local/share/ossim/ossim_preference
Explanation: top
height
return the MSL and ellipoid height given a latitude longitude position
ossim-info --height <latitude-in-degrees> <longitude-in-degrees>
End of explanation
!ossim-info --mtrsPerDeg 65.45
Explanation: top
Meters per degrees
Gives meters per degree and meters per minute for a given latitude.
ossim-info --mtrsPerDeg <latitude>
End of explanation
!ossim-info --datums
Explanation: top
Datums
Prints datum list.
ossim-info --datums
End of explanation
!ossim-info --projections
Explanation: Projections
Prints projections list
ossim-info --projections
End of explanation
!ossim-info --cg {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
Explanation: top
Explore raster data
ground center
```ossim-info --cg filename```
End of explanation
!ossim-info --ci {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
Explanation: top
image center
```ossim-info --ci filename```
End of explanation
!ossim-info -c {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
Explanation: top
ground and image center
```ossim-info -c filename```
End of explanation
!ossim-info -i {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
Explanation: top
general image information
```ossim-info -i filename```
End of explanation
!ossim-info -m {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
Explanation: top
meta data image information
ossim-info -m filename
End of explanation
!ossim-info -p {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
Explanation: top
image projection information
ossim-info -p filename
End of explanation
!ossim-info -r {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
Explanation: top
image rectangle
ossim-info -r filename
End of explanation
!ossim-img2rr {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
!ossim-img2rr {DATADIR}/p011r031_7t19990918_z19_nn20.tif -P /usr/local/share/ossim/ossim_preference
!ossim-img2rr {DATADIR}/p011r031_7t19990918_z19_nn30.tif -P /usr/local/share/ossim/ossim_preference
Explanation: top
ossim-img2rr
End of explanation
!ossim-cmm {DATADIR}/p011r031_7t19990918_z19_nn10.tif -P /usr/local/share/ossim/ossim_preference
!ossim-cmm {DATADIR}/p011r031_7t19990918_z19_nn20.tif -P /usr/local/share/ossim/ossim_preference
!ossim-cmm {DATADIR}/p011r031_7t19990918_z19_nn30.tif -P /usr/local/share/ossim/ossim_preference
!cat /home/main/notebooks/data/landsat/p011r031_7t19990918_z19_nn10.omd
Explanation: ossim-cmm
End of explanation
!ossim-img2md -P /usr/local/share/ossim/ossim_preference tiff_world_file {DATADIR}/p011r031_7t19990918_z19_nn10.tif {DATADIR}/p011r031_7t19990918_z19_nn10.tfw
!cat /home/main/notebooks/data/landsat//p011r031_7t19990918_z19_nn10.tfw
Explanation: ossim-img2md
Usage: ossim-img2md [options] <metadata_writer> <input_file> <output_file>
Valid metadata writer types:
envi_header
ers_header
ossim_fgdc
ossim_geometry
ossim_readme
tiff_world_file
jpeg_world_file
End of explanation
!ossim-band-merge jpeg -P /usr/local/share/ossim/ossim_preference \
{DATADIR}/p011r031_7t19990918_z19_nn30.tif \
{DATADIR}/p011r031_7t19990918_z19_nn20.tif \
{DATADIR}/p011r031_7t19990918_z19_nn10.tif \
rgb.jpeg
!ossim-cmm rgb.jpeg -P /usr/local/share/ossim/ossim_preference
!cat rgb.omd
Image("rgb.jpeg")
Explanation: ossim-band-merge
ossim-band-merge [-h][-o][-w tile_width] <output_type> <input_file1> <input_file2> ... <output_file>
Example, crete an RGB image from the single-band grayscale r,g,b images (Landsat 7)
End of explanation
!ossim-create-histo {DATADIR}/p011r031_7t19990918_z19_nn30.tif \
{DATADIR}/p011r031_7t19990918_z19_nn20.tif \
{DATADIR}/p011r031_7t19990918_z19_nn10.tif
!ossim-orthoigen --hist-auto-minmax {DATADIR}/p011r031_7t19990918_z19_nn30.tif {DATADIR}/p011r031_7t19990918_z19_nn30_histmm.tif -P /usr/local/share/ossim/ossim_preference
!ossim-orthoigen --hist-auto-minmax {DATADIR}/p011r031_7t19990918_z19_nn20.tif {DATADIR}/p011r031_7t19990918_z19_nn20_histmm.tif -P /usr/local/share/ossim/ossim_preference
!ossim-orthoigen --hist-auto-minmax {DATADIR}/p011r031_7t19990918_z19_nn10.tif {DATADIR}/p011r031_7t19990918_z19_nn10_histmm.tif -P /usr/local/share/ossim/ossim_preference
!ossim-band-merge jpeg -P /usr/local/share/ossim/ossim_preference \
{DATADIR}/p011r031_7t19990918_z19_nn30_histmm.tif \
{DATADIR}/p011r031_7t19990918_z19_nn20_histmm.tif \
{DATADIR}/p011r031_7t19990918_z19_nn10_histmm.tif \
rgb_histmm.jpeg
Image('rgb_histmm.jpeg')
Explanation: top
ossim-create-histo
End of explanation
!ossim-chipper --color 255 255 255 \
--azimuth 270 \
--elevation 45 \
--exaggeration 2.0 \
--op hillshade \
--color-table {DATADIR}/ossim-dem-color-table-template.kwl \
--input-dem {DATADIR}/SRTM_fB03_p011r031.tif \
hillshade.jpg -P /usr/local/share/ossim/ossim_preference
!ossim-info {DATADIR}/SRTM_fB03_p011r031.tif -P /usr/local/share/ossim/ossim_preference
!gdalinfo {DATADIR}/SRTM_fB03_p011r031.tif
Image('hillshade.jpg')
Explanation: ossim-chipper
End of explanation
# A complete list of ossim writers (driver) is given by:
!ossim-info --writers -P /usr/local/share/ossim/ossim_preference
#convert a geotiff to a geopdf
!ossim-icp ossim_pdf rgb_histmm.jpeg rgb_histmm.pdf
#view the results in a pdf viewer
#nohup evince lsat7_2002_30.pdf &
Explanation: top
ossim-icp
ossim-icp [options] <output_type> <input_file> <output_file>
End of explanation
#ossim-igen /home/user/ossim/rgb.spec
#display < /home/user/rgb.jpg
Explanation: top
ossim-igen
Execute image chains specified in a spec file.
In the folowing example the spec file rgb.spec has been generated using imagelinker, from an example session: /home/user/ossim/ossim-rgb.prj
End of explanation |
3,426 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Clasification of phishng and benign URLs
Loading dataset from CSV file
Data exploration with 2D and 3D plots
Classification with KNN
Drawing a boundary between classes with KNN
Dimensionality reduction with PCA and t-SNE
Clustering with k-Means
Step1: Dimensionality reduction with PCA
Step2: Dimensionality reduction with t-SNE
Step3: Clustering | Python Code:
# Load CSV
import pandas as pd
import numpy as np
filename = 'Examples - Phishing clasification2.csv'
# Specify the names of attributes if the header is not availabel in a CSV file
#names = ['Registrar', 'Lifetime', 'Country', 'Class']
# Loading with NumPy
#raw_data = open(filename, 'rt')
#data = numpy.loadtxt(raw_data, delimiter=",")
# Loading with Pandas
data = pd.read_csv(filename)
print(data.shape)
#data
#data.dtypes
# Transforming 'object' data to 'categorical' to get numerical (ordinal numbers) representation
data['Registrar'] = data['Registrar'].astype('category')
data['Country'] = data['Country'].astype('category')
data['Protocol'] = data['Protocol'].astype('category')
data['Class'] = data['Class'].astype('category')
data['Registrar_code'] = data['Registrar'].cat.codes
data['Country_code'] = data['Country'].cat.codes
data['Protocol_code'] = data['Protocol'].cat.codes
data['Class_code'] = data['Class'].cat.codes
#data.dtypes
pd.options.display.max_rows=1000
data
#pd.options.display.max_rows=100
X = data[['Registrar_code', 'Lifetime', 'Country_code', 'Protocol_code']].values #Feature Matrix
y = data['Class_code'].values #Target Variable
feature_names = data[['Registrar_code', 'Lifetime', 'Country_code', 'Protocol_code']].columns.values
#print(feature_names)
target_names = data['Class'].cat.categories
country_names = data['Country'].cat.categories
registrar_names = data['Registrar'].cat.categories
protocol_names = data['Protocol'].cat.categories
#print(target_names, country_names, registrar_names)
import matplotlib.pyplot as plt
x_index = 1
y_index = 3
# this formatter will label the colorbar with the correct target names
formatter = plt.FuncFormatter(lambda i, *args: target_names[int(i)])
plt.scatter(X[:, x_index], X[:, y_index], c=y, cmap=plt.cm.get_cmap('Paired', 2))
plt.colorbar(ticks=[0, 1], format=formatter)
plt.clim(-0.5, 1.5)
plt.xlabel(feature_names[x_index])
plt.ylabel(feature_names[y_index]);
plt.show()
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure(1, figsize=(10, 8))
plt.clf()
ax = Axes3D(fig, rect=[0, 0, 1, 1], elev=30, azim=100)
ax.scatter(X[:, 1], X[:, 2], X[:, 3], lw=2, c=y, cmap='Paired')
ax.set_xlabel(feature_names[1])
ax.set_ylabel(feature_names[2]);
ax.set_zlabel(feature_names[3]);
plt.show()
from sklearn import neighbors
# create the model
knn = neighbors.KNeighborsClassifier(n_neighbors=5)
# fit the model
knn.fit(X, y)
# call the "predict" method:
registrar_code = 48
lifetime = 2
country_code = 28
protocol_code = 1
result = knn.predict([[registrar_code, lifetime, country_code, protocol_code],])
#print(target_names)
print(result, target_names[result[0]], ": ", registrar_names[registrar_code], lifetime, country_names[country_code], protocol_names[protocol_code] )
from matplotlib.colors import ListedColormap
n_neighbors = 5
h = .02 # step size in the mesh
# Create color maps
cmap_light = ListedColormap(['cyan', 'red'])
cmap_bold = ListedColormap(['blue', 'orange'])
# Get '1: Lifetime' and '2: Country' attributes only
x_index = 1
y_index = 2
X2 = X[:,[x_index, y_index]]
for weights in ['uniform', 'distance']:
# we create an instance of Neighbours Classifier and fit the data.
knn = neighbors.KNeighborsClassifier(n_neighbors, weights=weights)
knn.fit(X2, y)
# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, x_max]x[y_min, y_max].
x_min, x_max = X2[:, 0].min() - 1, X2[:, 0].max() + 1
y_min, y_max = X2[:, 1].min() - 1, X2[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = knn.predict(np.c_[xx.ravel(), yy.ravel()])
# Put the result into a color plot
Z = Z.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx, yy, Z, cmap=cmap_light)
# Plot also the training points
plt.scatter(X2[:, 0], X2[:, 1], c=y, cmap=cmap_bold,
edgecolor='k', s=20)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.title("2-Class classification (k = %i, weights = '%s')"
% (n_neighbors, weights))
plt.xlabel(feature_names[x_index])
plt.ylabel(feature_names[y_index]);
plt.show()
Explanation: Clasification of phishng and benign URLs
Loading dataset from CSV file
Data exploration with 2D and 3D plots
Classification with KNN
Drawing a boundary between classes with KNN
Dimensionality reduction with PCA and t-SNE
Clustering with k-Means
End of explanation
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pca.fit(X)
X_reduced = pca.transform(X)
print("Reduced dataset shape:", X_reduced.shape)
# PCA only
plt.scatter(X_reduced[:, 0], X_reduced[:, 1], c=y, cmap='Paired')
print("Meaning of the components:")
for component in pca.components_:
print(" + ".join("%.3f x %s" % (value, name)
for value, name in zip(component, feature_names)))
Explanation: Dimensionality reduction with PCA
End of explanation
from sklearn.manifold import TSNE
X_reduced2 = TSNE(n_components=2).fit_transform(X)
# PCA + t-SNE
X_reduced3 = TSNE(n_components=2).fit_transform(X_reduced)
print("Reduced dataset shape:", X_reduced3.shape)
# t-SNE only
plt.scatter(X_reduced2[:, 0], X_reduced2[:, 1], c=y, cmap='Paired')
# PCA + t-SNE
plt.scatter(X_reduced3[:, 0], X_reduced3[:, 1], c=y, cmap='Paired')
Explanation: Dimensionality reduction with t-SNE
End of explanation
from sklearn.cluster import KMeans
k_means = KMeans(n_clusters=2, random_state=0) # Fixing the RNG in kmeans
k_means.fit(X)
y_pred = k_means.predict(X)
plt.scatter(X_reduced2[:, 0], X_reduced2[:, 1], c=y_pred, cmap='Paired');
TP = 0
TN = 0
FP = 0
FN = 0
for i in range (0, len(y)):
#print(i, ":", y[i])
if (y[i] == 1): # Positive
if (y[i] == y_pred[i]):
TP+=1
else:
FN+=1
else:
if (y[i] == y_pred[i]):
TN+=1
else:
FP+=1
print("TP =", TP, "TN =", TN, "FP =", FP, "FN =", FN)
TPR = TP / (TP+FN)
TNR = TN / (TN+FP)
FPR = FP / (FP+TN)
FNR = FN / (TP+FN)
PPV = (TP+TN) / (TP+TN+FP+FN)
NPV = TN / (TN+FN)
Fmeasure = 2*PPV*TPR / (PPV + TPR)
print("TPR =", TPR, "TNR =", TNR, "FPR =", FPR, "FNR =", FNR, "PPV =", PPV, "NPV =", NPV, "F-measure =", Fmeasure)
Explanation: Clustering: K-means
End of explanation |
3,427 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Nexa Wall Street Columns Raw Data, Low Resolution vs High Resolution, NData
Here we compare how well the LDA classifier works for both low resolution and high resolution classification when we change the number of letters it can actually use.
Step1: Load both high and low resolution data and the letters
Step2: Calculate scalability with Ndata
Inclusive Policy
Main parameters
Step3: Extract the data
Step4: Do the calculation for low resolution
Step5: Do the high resolution calculations
Step6: Plot scores as a function Ndata
Step7: Plot them by number of letters instead
Step8: Exclusive Policy
Main parameters
Step9: Extract the data
Step10: Do the calculation for low resolution
Step11: Do the caluclation for high resoultion
Step12: Plot scores as a function of Ndata
Step13: Plot scores as a function of letters | Python Code:
import numpy as np
from sklearn import cross_validation
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
import h5py
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
import sys
sys.path.append("../")
from aux.raw_images_columns_functions import extract_column_data, extract_letters_to_columns
Explanation: Nexa Wall Street Columns Raw Data, Low Resolution vs High Resolution, NData
Here we compare how well the LDA classifier works for both low resolution and high resolution classification when we change the number of letters it can actually use.
End of explanation
# Load low resolution signal
signal_location_low = '../data/wall_street_data_spaces.hdf5'
with h5py.File(signal_location_low, 'r') as f:
dset = f['signal']
signals_low = np.empty(dset.shape, np.float)
dset.read_direct(signals_low)
# Load high resolution signal
signal_location_high = '../data/wall_street_data_30.hdf5'
with h5py.File(signal_location_high, 'r') as f:
dset = f['signal']
signals_high = np.empty(dset.shape, np.float)
dset.read_direct(signals_high)
# Load the letters
# Now we need to get the letters and align them
text_directory = '../data/wall_street_letters_spaces.npy'
letters_sequence = np.load(text_directory)
Explanation: Load both high and low resolution data and the letters
End of explanation
MaxNletters = 2500
shift = 0 # Predict within or next letter
policy = 'inclusive' # The type of the policy fo the letter covering
Nside_low = signals_low.shape[1]
max_lag_low = 5
Nside_high = signals_high.shape[1]
max_lag_high = 15
Explanation: Calculate scalability with Ndata
Inclusive Policy
Main parameters
End of explanation
# Low resolution
data_low = extract_column_data(MaxNletters, Nside_low, max_lag_low, signals_low, policy=policy)
letters_low = extract_letters_to_columns(MaxNletters, Nside_low, max_lag_low,
letters_sequence, policy=policy, shift=shift)
# High resolution
data_high = extract_column_data(MaxNletters, Nside_high, max_lag_high, signals_high, policy=policy)
letters_high = extract_letters_to_columns(MaxNletters, Nside_high, max_lag_high,
letters_sequence, policy=policy, shift=shift)
# Now let's do classification for different number of data
print('Policy', policy)
MaxN_lowdata = letters_low.size
MaxN_high_data = letters_high.size
print('Ndata for the low resolution', MaxN_lowdata)
print('Ndata for the high resolution', MaxN_high_data)
Explanation: Extract the data
End of explanation
Ndata_array = np.arange(500, 24500, 500)
score_low = []
for Ndata_class in Ndata_array:
# First we get the classification for low resolution
X = data_low[:Ndata_class, ...].reshape(Ndata_class, Nside_low * max_lag_low)
y = letters_low[:Ndata_class, ...]
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=0.10)
clf = LDA()
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test) * 100
score_low.append(score)
Explanation: Do the calculation for low resolution
End of explanation
Ndata_array = np.arange(500, 24500, 500)
score_high = []
for Ndata_class in Ndata_array:
# First we get the classification for low resolution
X = data_high[:Ndata_class, ...].reshape(Ndata_class, Nside_high * max_lag_high)
y = letters_high[:Ndata_class, ...]
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=0.10)
clf = LDA()
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test) * 100
score_high.append(score)
Explanation: Do the high resolution calculations
End of explanation
sns.set(font_scale=2)
fig = plt.figure(figsize=(16, 12))
ax = fig.add_subplot(111)
ax.plot(Ndata_array, score_high, 'o-', label='high resolution', lw=3, markersize=10)
ax.plot(Ndata_array, score_low, 'o-', label='low resolution', lw=3, markersize=10)
ax.legend()
ax.set_ylim(0, 105)
ax.set_ylabel('Accuracy')
ax.set_xlabel('Ndata')
ax.set_title('Accuracy vs Number of Data for High Resolution (same letter - inclusive policy)')
Explanation: Plot scores as a function Ndata
End of explanation
sns.set(font_scale=2)
fig = plt.figure(figsize=(16, 12))
# Low resolution
ax1 = fig.add_subplot(211)
Nletters_array = Ndata_array / Nside_low
ax1.plot(Nletters_array, score_low, 'o-', lw=3, markersize=10)
ax1.set_ylim(0, 105)
ax1.set_ylabel('Accuracy')
ax1.set_xlabel('Nletters')
# High resolution
ax2 = fig.add_subplot(212)
Nletters_array = Ndata_array / Nside_high
ax2.plot(Nletters_array, score_high, 'o-', lw=3, markersize=10)
ax2.set_ylim(0, 105)
ax2.set_ylabel('Accuracy')
ax2.set_xlabel('Nletters')
Explanation: Plot them by number of letters instead
End of explanation
MaxNletters = 2500
shift = 0 # Predict within or next letter
policy = 'exclusive' # The type of the policy fo the letter covering
Nside_low = signals_low.shape[1]
max_lag_low = 5
Nside_high = signals_high.shape[1]
max_lag_high = 15
Explanation: Exclusive Policy
Main parameters
End of explanation
# Low resolution
data_low = extract_column_data(MaxNletters, Nside_low, max_lag_low, signals_low, policy=policy)
letters_low = extract_letters_to_columns(MaxNletters, Nside_low, max_lag_low,
letters_sequence, policy=policy, shift=shift)
# High resolution
data_high = extract_column_data(MaxNletters, Nside_high, max_lag_high, signals_high, policy=policy)
letters_high = extract_letters_to_columns(MaxNletters, Nside_high, max_lag_high,
letters_sequence, policy=policy, shift=shift)
# Now let's do classification for different number of data
print('Policy', policy)
MaxN_lowdata = letters_low.size
MaxN_high_data = letters_high.size
print('Ndata for the low resolution', MaxN_lowdata)
print('Ndata for the high resolution', MaxN_high_data)
Explanation: Extract the data
End of explanation
Ndata_array = np.arange(500, 24500, 500)
score_low = []
for Ndata_class in Ndata_array:
# First we get the classification for low resolution
X = data_high[:Ndata_class, ...].reshape(Ndata_class, Nside_high * max_lag_high)
y = letters_high[:Ndata_class, ...]
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=0.10)
clf = LDA()
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test) * 100
score_low.append(score)
Explanation: Do the calculation for low resolution
End of explanation
Ndata_array = np.arange(500, 24500, 500)
score_high = []
for Ndata_class in Ndata_array:
# First we get the classification for low resolution
X = data_high[:Ndata_class, ...].reshape(Ndata_class, Nside_high * max_lag_high)
y = letters_high[:Ndata_class, ...]
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=0.10)
clf = LDA()
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test) * 100
score_high.append(score)
Explanation: Do the caluclation for high resoultion
End of explanation
sns.set(font_scale=2)
fig = plt.figure(figsize=(16, 12))
ax = fig.add_subplot(111)
ax.plot(Ndata_array, score_high, 'o-', label='high resolution', lw=3, markersize=10)
ax.plot(Ndata_array, score_low, 'o-', label='low resolution', lw=3, markersize=10)
ax.legend()
ax.set_ylim(0, 105)
ax.set_ylabel('Accuracy')
ax.set_xlabel('Ndata')
ax.set_title('Accuracy vs Number of Data for High Resolution (same letter - exclusive policy)')
Explanation: Plot scores as a function of Ndata
End of explanation
sns.set(font_scale=2)
fig = plt.figure(figsize=(16, 12))
# Low resolution
ax1 = fig.add_subplot(211)
Nletters_array = Ndata_array / (Nside_low + max_lag_low + 1)
ax1.plot(Nletters_array, score_low, 'o-', lw=3, markersize=10)
ax1.set_ylim(0, 105)
ax1.set_ylabel('Accuracy')
ax1.set_xlabel('Nletters')
# High resolution
ax2 = fig.add_subplot(212)
Nletters_array = Ndata_array / (Nside_high + max_lag_high + 1)
ax2.plot(Nletters_array, score_high, 'o-', lw=3, markersize=10)
ax2.set_ylim(0, 105)
ax2.set_ylabel('Accuracy')
ax2.set_xlabel('Nletters')
Explanation: Plot scores as a function of letters
End of explanation |
3,428 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Outlier Detection by Example
Outlier detection has been available in machine learning since 7.2 - what follows is a demonstration about how to create outlier detection analyses and how to analyze the results.
For the sake of demonstration, we'll be using an artifical two-dimensional dataset that I've created using numpy and scikit-learn.
Step1: This dataset contains 2500 points normally-distributed around two main clusters centers at (-1, -1) and (3, 1). Scikit-learn's make_blobs method allows us to control the standard deviations of each cluster, which I've set to 1.25 and 0.5, respectively. This allows us to see how outlier detection functions on data with differing densities.
After making the data clusters, we introduce 99 new points, with x and y locations randomly sampled from a uniform distribution. Some of these points will fall well outside the clusters we created and should be deemed outliers; others will lie within the clusters and appear as normal points.
In the visualization below the added points are marked with an orange X and the original points are marked as blue dots.
Step2: Elasticsearch
Index Data
Let's use the elasticsearch python client to ingest this data into elasticsearch. This step requires a local elasticsearch cluster running on port 9200.
Step3: Create Outlier Analysis
Now we will send a request to elasticsearch to create our outlier analysis. The configuration for the analysis requires the following
Step4: Start Analysis
Step5: The analysis should complete in less that a minute.
Analyze Results
Now that our analysis is finished, let's view the results. We'll pull the data back into python using the helpers.scan() method from the elasticsearch python client. We see that our new blobs-outliers index contains information output by the outlier detection analysis
Step6: Now, we can view our original data again, this time coloring the points based on their outlier score. Here, blue values correspond to low scores, and pink values correspond to high scores.
We can see how our cluster densities affect the scoring. There appears to be a marked increase in outlier scores for points just outside the right cluster. Compare this to the less clearly defined border of the left cluster; we can see that the increase in scores is less drastic for points spreading away from the cluster.
Also note the high scores for points that sit on the edges of the figure - these points lie far away from both clusters.
Step7: Now, let's overlay feature influence on this visualization. Below, we see the same points with ellipses whose width and height correspond to the influence of x and y, respectively, on that points outlier score.
Note how the ellipses in the upper left of our space are almost circular - they are outlier because the sit far away from the clusters in both the x and y dimensions. Ellipses in the upper right (above the right cluster) are so narrow that they appear almost as lines - this is because their x values fall well within the range of x values for the right cluster, while their y values abnormally exceed the typical y values of points in the right cluster. | Python Code:
n_dim = 2
n_samples = 2500
data = make_blobs(centers=[[-1, -1], [3, 1]],
cluster_std=[1.25, 0.5],
n_samples=n_samples,
n_features=n_dim)[0]
# add outliers from a uniform distribution [-6,6]
n_outliers = 99
rng = np.random.RandomState(19)
outliers = rng.uniform(low=-5, high=5, size=(n_outliers, n_dim))
# add the outliers back into the data
data = np.concatenate([data, outliers], axis=0)
Explanation: Outlier Detection by Example
Outlier detection has been available in machine learning since 7.2 - what follows is a demonstration about how to create outlier detection analyses and how to analyze the results.
For the sake of demonstration, we'll be using an artifical two-dimensional dataset that I've created using numpy and scikit-learn.
End of explanation
fig, ax = plt.subplots(figsize=(6,6), facecolor='white')
plt.scatter(data[:2500, 0], data[:2500, 1], alpha=0.25, cmap='cool', marker='.', s=91)
plt.scatter(data[2500:, 0], data[2500:, 1], alpha=0.5, cmap='cool', marker='x', s=91)
plt.clim(0,1)
plt.grid(True)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.yaxis.grid(color='gray', alpha=0.25, linestyle='dashed')
ax.xaxis.grid(color='gray', alpha=0.25, linestyle='dashed')
ax.set_axisbelow(True)
Explanation: This dataset contains 2500 points normally-distributed around two main clusters centers at (-1, -1) and (3, 1). Scikit-learn's make_blobs method allows us to control the standard deviations of each cluster, which I've set to 1.25 and 0.5, respectively. This allows us to see how outlier detection functions on data with differing densities.
After making the data clusters, we introduce 99 new points, with x and y locations randomly sampled from a uniform distribution. Some of these points will fall well outside the clusters we created and should be deemed outliers; others will lie within the clusters and appear as normal points.
In the visualization below the added points are marked with an orange X and the original points are marked as blue dots.
End of explanation
host = "http://localhost:9200"
es = Elasticsearch(host)
# take our iteratble, data, and build a generator to pass to elasticsearch-py's helper function
def gen_blobs():
for point in data:
yield {
"_index": "blobs",
"_type": "document",
"x": point[0],
"y": point[1]
}
helpers.bulk(es, gen_blobs())
Explanation: Elasticsearch
Index Data
Let's use the elasticsearch python client to ingest this data into elasticsearch. This step requires a local elasticsearch cluster running on port 9200.
End of explanation
api = "/_ml/data_frame/analytics/blobs-outlier-detection"
config = {
"source": {
"index": "blobs",
"query": {"match_all": {}}
},
"dest": {
"index": "blobs-outliers"
},
"analysis": {
"outlier_detection": {}
},
"analyzed_fields": {
"includes": ["x", "y"],
"excludes": []
}
}
print(requests.put(host+api, json=config).json())
Explanation: Create Outlier Analysis
Now we will send a request to elasticsearch to create our outlier analysis. The configuration for the analysis requires the following:
a source index. This is the index blobs that we just ingested. Optionally, we can add a query to our index to just run outlier detection on a subset of the data.
a dest index. The data from source will be reindexed into the destination index and the outlier detection analysis will add the results directly to this index.
the analysis configuration. Here we're specifying that we want to run outlier-detection. Other options include regression and classification.
an analyzed_fields object that instructs the analysis which fields to include and exclude.
End of explanation
api = "/_ml/data_frame/analytics/blobs-outlier-detection/_start"
print(requests.post(host+api).json())
Explanation: Start Analysis
End of explanation
es_data = []
for blob in helpers.scan(es, index='blobs-outliers'):
obj = [
blob['_source']['x'],
blob['_source']['y'],
blob['_source']['ml']['outlier_score'],
blob['_source']['ml'].get('feature_influence.x', 0),
blob['_source']['ml'].get('feature_influence.y', 0)
]
es_data.append(obj)
es_data = np.asarray(es_data)
Explanation: The analysis should complete in less that a minute.
Analyze Results
Now that our analysis is finished, let's view the results. We'll pull the data back into python using the helpers.scan() method from the elasticsearch python client. We see that our new blobs-outliers index contains information output by the outlier detection analysis:
ml.outlier_score: the overall outlier score of the data point representated as a value between 0 and 1.
ml.feature_influence.x: the influence that the field x had on the outlier score representated as a value between 0 and 1.
ml.feature_influence.y: the influence that the field y had on the outlier score representated as a value between 0 and 1.
For more information about how outlier scores and feature influence are calculated, please see the Outlier Detection Documentation. And if you're especially curious about how our modeling compares to other outlier detection models out there, have a look at this recent blog post where we benchmarked our outlier detection against many other algorithms.
End of explanation
fig, ax = plt.subplots(figsize=(10,7), facecolor='white')
plt.scatter(es_data[:, 0], es_data[:, 1], c=es_data[:, 2], cmap='cool', marker='.')
plt.clim(0,1)
plt.grid(True)
cb = plt.colorbar()
cb.outline.set_visible(False)
cb.ax.get_yaxis().labelpad = 25
cb.ax.set_ylabel('outlier score', rotation=270)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.yaxis.grid(color='gray', alpha=0.25, linestyle='dashed')
ax.xaxis.grid(color='gray', alpha=0.25, linestyle='dashed')
ax.set_axisbelow(True)
Explanation: Now, we can view our original data again, this time coloring the points based on their outlier score. Here, blue values correspond to low scores, and pink values correspond to high scores.
We can see how our cluster densities affect the scoring. There appears to be a marked increase in outlier scores for points just outside the right cluster. Compare this to the less clearly defined border of the left cluster; we can see that the increase in scores is less drastic for points spreading away from the cluster.
Also note the high scores for points that sit on the edges of the figure - these points lie far away from both clusters.
End of explanation
from matplotlib.patches import Ellipse
cmap = matplotlib.cm.get_cmap('cool')
fig, ax = plt.subplots(figsize=(10,7), facecolor='white')
ell = [[Ellipse(xy = (blob[0], blob[1]), width=blob[3], height=blob[4]), blob[2]] for blob in es_data if blob[2]>0.5]
for e in ell:
ax.add_artist(e[0])
e[0].set_clip_box(ax.bbox)
e[0].set_alpha(0.25)
e[0].set_facecolor(cmap(e[1]))
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.yaxis.grid(color='gray', alpha=0.25, linestyle='dashed')
ax.xaxis.grid(color='gray', alpha=0.25, linestyle='dashed')
plt.scatter(es_data[:, 0], es_data[:, 1], c=es_data[:, 2], cmap='cool', marker='.')
cb = plt.colorbar()
cb.outline.set_visible(False)
cb.ax.get_yaxis().labelpad = 25
cb.ax.set_ylabel('outlier score', rotation=270)
ax.set_xlim(-6, 6)
ax.set_ylim(-6, 6);
Explanation: Now, let's overlay feature influence on this visualization. Below, we see the same points with ellipses whose width and height correspond to the influence of x and y, respectively, on that points outlier score.
Note how the ellipses in the upper left of our space are almost circular - they are outlier because the sit far away from the clusters in both the x and y dimensions. Ellipses in the upper right (above the right cluster) are so narrow that they appear almost as lines - this is because their x values fall well within the range of x values for the right cluster, while their y values abnormally exceed the typical y values of points in the right cluster.
End of explanation |
3,429 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
The Lines Mark
Lines is a Mark object that is primarily used to visualize quantitative data. It works particularly well for continuous data, or when the shape of the data needs to be extracted.
Introduction
The Lines object provides the following features
Step1: Random Data Generation
Step2: Basic Line Chart
Using the bqplot, object oriented API, we can generate a Line Chart with the following code snippet
Step3: The x attribute refers to the data represented horizontally, while the y attribute refers the data represented vertically.
We can explore the different attributes by changing each of them for the plot above
Step4: In a similar way, we can also change any attribute after the plot has been displayed to change the plot. Run each of the cells below, and try changing the attributes to explore the different features and how they affect the plot.
Step5: To switch to an area chart, set the fill attribute, and control the look with fill_opacities and fill_colors.
Step6: While a Lines plot allows the user to extract the general shape of the data being plotted, there may be a need to visualize discrete data points along with this shape. This is where the markers attribute comes in.
Step7: The marker attributes accepts the values square, circle, cross, diamond, square, triangle-down, triangle-up, arrow, rectangle, ellipse. Try changing the string above and re-running the cell to see how each marker type looks.
Plotting a Time-Series
The DateScale allows us to plot time series as a Lines plot conveniently with most date formats.
Step8: Plotting Multiples Sets of Data with Lines
The Lines mark allows the user to plot multiple y-values for a single x-value. This can be done by passing an ndarray or a list of the different y-values as the y-attribute of the Lines as shown below.
Step9: We pass each data set as an element of a list. The colors attribute allows us to pass a specific color for each line.
Step10: Similarly, we can also pass multiple x-values for multiple sets of y-values
Step11: Coloring Lines according to data
The color attribute of a Lines mark can also be used to encode one more dimension of data. Suppose we have a portfolio of securities and we would like to color them based on whether we have bought or sold them. We can use the color attribute to encode this information.
Step12: We can also reset the colors of the Line to their defaults by setting the color attribute to None.
Step13: Patches
The fill attribute of the Lines mark allows us to fill a path in different ways, while the fill_colors attribute lets us control the color of the fill | Python Code:
import numpy as np #For numerical programming and multi-dimensional arrays
from pandas import date_range #For date-rate generation
from bqplot import LinearScale, Lines, Axis, Figure, DateScale, ColorScale
Explanation: The Lines Mark
Lines is a Mark object that is primarily used to visualize quantitative data. It works particularly well for continuous data, or when the shape of the data needs to be extracted.
Introduction
The Lines object provides the following features:
Ability to plot a single set or multiple sets of y-values as a function of a set or multiple sets of x-values
Ability to style the line object in different ways, by setting different attributes such as the colors, line_style, stroke_width etc.
Ability to specify a marker at each point passed to the line. The marker can be a shape which is at the data points between which the line is interpolated and can be set through the markers attribute
The Lines object has the following attributes
| Attribute | Description | Default Value |
|:-:|---|:-:|
| colors | Sets the color of each line, takes as input a list of any RGB, HEX, or HTML color name | CATEGORY10 |
| opacities | Controls the opacity of each line, takes as input a real number between 0 and 1 | 1.0 |
| stroke_width | Real number which sets the width of all paths | 2.0 |
| line_style | Specifies whether a line is solid, dashed, dotted or both dashed and dotted | 'solid' |
| interpolation | Sets the type of interpolation between two points | 'linear' |
| marker | Specifies the shape of the marker inserted at each data point | None |
| marker_size | Controls the size of the marker, takes as input a non-negative integer | 64 |
|close_path| Controls whether to close the paths or not | False |
|fill| Specifies in which way the paths are filled. Can be set to one of {'none', 'bottom', 'top', 'inside'}| None |
|fill_colors| List that specifies the fill colors of each path | [] |
| Data Attribute | Description | Default Value |
|x |abscissas of the data points | array([]) |
|y |ordinates of the data points | array([]) |
|color | Data according to which the Lines will be colored. Setting it to None defaults the choice of colors to the colors attribute | None |
To explore more features, run the following lines of code:
python
from bqplot import Lines
?Lines
or visit the Lines documentation page
Let's explore these features one by one
We begin by importing the modules that we will need in this example
End of explanation
security_1 = np.cumsum(np.random.randn(150)) + 100.
security_2 = np.cumsum(np.random.randn(150)) + 100.
Explanation: Random Data Generation
End of explanation
sc_x = LinearScale()
sc_y = LinearScale()
line = Lines(x=np.arange(len(security_1)), y=security_1,
scales={'x': sc_x, 'y': sc_y})
ax_x = Axis(scale=sc_x, label='Index')
ax_y = Axis(scale=sc_y, orientation='vertical', label='y-values of Security 1')
Figure(marks=[line], axes=[ax_x, ax_y], title='Security 1')
Explanation: Basic Line Chart
Using the bqplot, object oriented API, we can generate a Line Chart with the following code snippet:
End of explanation
line.colors = ['DarkOrange']
Explanation: The x attribute refers to the data represented horizontally, while the y attribute refers the data represented vertically.
We can explore the different attributes by changing each of them for the plot above:
End of explanation
# The opacity allows us to display the Line while featuring other Marks that may be on the Figure
line.opacities = [.5]
line.stroke_width = 2.5
Explanation: In a similar way, we can also change any attribute after the plot has been displayed to change the plot. Run each of the cells below, and try changing the attributes to explore the different features and how they affect the plot.
End of explanation
line.fill = 'bottom'
line.fill_opacities = [0.2]
line.line_style = 'dashed'
line.interpolation = 'basis'
Explanation: To switch to an area chart, set the fill attribute, and control the look with fill_opacities and fill_colors.
End of explanation
line.marker = 'triangle-down'
Explanation: While a Lines plot allows the user to extract the general shape of the data being plotted, there may be a need to visualize discrete data points along with this shape. This is where the markers attribute comes in.
End of explanation
# Here we define the dates we would like to use
dates = date_range(start='01-01-2007', periods=150)
dt_x = DateScale()
sc_y = LinearScale()
time_series = Lines(x=dates, y=security_1, scales={'x': dt_x, 'y': sc_y})
ax_x = Axis(scale=dt_x, label='Date')
ax_y = Axis(scale=sc_y, orientation='vertical', label='Security 1')
Figure(marks=[time_series], axes=[ax_x, ax_y], title='A Time Series Plot')
Explanation: The marker attributes accepts the values square, circle, cross, diamond, square, triangle-down, triangle-up, arrow, rectangle, ellipse. Try changing the string above and re-running the cell to see how each marker type looks.
Plotting a Time-Series
The DateScale allows us to plot time series as a Lines plot conveniently with most date formats.
End of explanation
x_dt = DateScale()
y_sc = LinearScale()
Explanation: Plotting Multiples Sets of Data with Lines
The Lines mark allows the user to plot multiple y-values for a single x-value. This can be done by passing an ndarray or a list of the different y-values as the y-attribute of the Lines as shown below.
End of explanation
dates_new = date_range(start='06-01-2007', periods=150)
securities = np.cumsum(np.random.randn(150, 10), axis=0)
positions = np.random.randint(0, 2, size=10)
# We pass the color scale and the color data to the lines
line = Lines(x=dates, y=[security_1, security_2],
scales={'x': x_dt, 'y': y_sc},
labels=['Security 1', 'Security 2'])
ax_x = Axis(scale=x_dt, label='Date')
ax_y = Axis(scale=y_sc, orientation='vertical', label='Security 1')
Figure(marks=[line], axes=[ax_x, ax_y], legend_location='top-left')
Explanation: We pass each data set as an element of a list. The colors attribute allows us to pass a specific color for each line.
End of explanation
line.x, line.y = [dates, dates_new], [security_1, security_2]
Explanation: Similarly, we can also pass multiple x-values for multiple sets of y-values
End of explanation
x_dt = DateScale()
y_sc = LinearScale()
col_sc = ColorScale(colors=['Red', 'Green'])
dates_color = date_range(start='06-01-2007', periods=150)
securities = 100. + np.cumsum(np.random.randn(150, 10), axis=0)
positions = np.random.randint(0, 2, size=10)
# Here we generate 10 random price series and 10 random positions
# We pass the color scale and the color data to the lines
line = Lines(x=dates_color, y=securities.T,
scales={'x': x_dt, 'y': y_sc, 'color': col_sc}, color=positions,
labels=['Security 1', 'Security 2'])
ax_x = Axis(scale=x_dt, label='Date')
ax_y = Axis(scale=y_sc, orientation='vertical', label='Security 1')
Figure(marks=[line], axes=[ax_x, ax_y], legend_location='top-left')
Explanation: Coloring Lines according to data
The color attribute of a Lines mark can also be used to encode one more dimension of data. Suppose we have a portfolio of securities and we would like to color them based on whether we have bought or sold them. We can use the color attribute to encode this information.
End of explanation
line.color = None
Explanation: We can also reset the colors of the Line to their defaults by setting the color attribute to None.
End of explanation
sc_x = LinearScale()
sc_y = LinearScale()
patch = Lines(x=[[0, 2, 1.2, np.nan, np.nan, np.nan, np.nan], [0.5, 2.5, 1.7, np.nan, np.nan, np.nan, np.nan], [4,5,6, 6, 5, 4, 3]],
y=[[0, 0, 1 , np.nan, np.nan, np.nan, np.nan], [0.5, 0.5, -0.5, np.nan, np.nan, np.nan, np.nan], [1, 1.1, 1.2, 2.3, 2.2, 2.7, 1.0]],
fill_colors=['orange', 'blue', 'red'],
fill='inside',
stroke_width=10,
close_path=True,
scales={'x': sc_x, 'y': sc_y},
display_legend=True)
Figure(marks=[patch], animation_duration=1000)
patch.opacities = [0.1, 0.2]
patch.x = [[2, 3, 3.2, np.nan, np.nan, np.nan, np.nan], [0.5, 2.5, 1.7, np.nan, np.nan, np.nan, np.nan], [4,5,6, 6, 5, 4, 3]]
patch.close_path = False
Explanation: Patches
The fill attribute of the Lines mark allows us to fill a path in different ways, while the fill_colors attribute lets us control the color of the fill
End of explanation |
3,430 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
2 samples permutation test on source data with spatio-temporal clustering
Tests if the source space data are significantly different between
2 groups of subjects (simulated here using one subject's data).
The multiple comparisons problem is addressed with a cluster-level
permutation test across space and time.
Step1: Set parameters
Step2: Compute statistic
To use an algorithm optimized for spatio-temporal clustering, we
just pass the spatial adjacency matrix (instead of spatio-temporal)
Step3: Visualize the clusters | Python Code:
# Authors: Alexandre Gramfort <[email protected]>
# Eric Larson <[email protected]>
# License: BSD-3-Clause
import numpy as np
from scipy import stats as stats
import mne
from mne import spatial_src_adjacency
from mne.stats import spatio_temporal_cluster_test, summarize_clusters_stc
from mne.datasets import sample
print(__doc__)
Explanation: 2 samples permutation test on source data with spatio-temporal clustering
Tests if the source space data are significantly different between
2 groups of subjects (simulated here using one subject's data).
The multiple comparisons problem is addressed with a cluster-level
permutation test across space and time.
End of explanation
data_path = sample.data_path()
meg_path = data_path / 'MEG' / 'sample'
stc_fname = meg_path / 'sample_audvis-meg-lh.stc'
subjects_dir = data_path / 'subjects'
src_fname = subjects_dir / 'fsaverage' / 'bem' / 'fsaverage-ico-5-src.fif'
# Load stc to in common cortical space (fsaverage)
stc = mne.read_source_estimate(stc_fname)
stc.resample(50, npad='auto')
# Read the source space we are morphing to
src = mne.read_source_spaces(src_fname)
fsave_vertices = [s['vertno'] for s in src]
morph = mne.compute_source_morph(stc, 'sample', 'fsaverage',
spacing=fsave_vertices, smooth=20,
subjects_dir=subjects_dir)
stc = morph.apply(stc)
n_vertices_fsave, n_times = stc.data.shape
tstep = stc.tstep * 1000 # convert to milliseconds
n_subjects1, n_subjects2 = 6, 7
print('Simulating data for %d and %d subjects.' % (n_subjects1, n_subjects2))
# Let's make sure our results replicate, so set the seed.
np.random.seed(0)
X1 = np.random.randn(n_vertices_fsave, n_times, n_subjects1) * 10
X2 = np.random.randn(n_vertices_fsave, n_times, n_subjects2) * 10
X1[:, :, :] += stc.data[:, :, np.newaxis]
# make the activity bigger for the second set of subjects
X2[:, :, :] += 3 * stc.data[:, :, np.newaxis]
# We want to compare the overall activity levels for each subject
X1 = np.abs(X1) # only magnitude
X2 = np.abs(X2) # only magnitude
Explanation: Set parameters
End of explanation
print('Computing adjacency.')
adjacency = spatial_src_adjacency(src)
# Note that X needs to be a list of multi-dimensional array of shape
# samples (subjects_k) × time × space, so we permute dimensions
X1 = np.transpose(X1, [2, 1, 0])
X2 = np.transpose(X2, [2, 1, 0])
X = [X1, X2]
# Now let's actually do the clustering. This can take a long time...
# Here we set the threshold quite high to reduce computation,
# and use a very low number of permutations for the same reason.
n_permutations = 50
p_threshold = 0.001
f_threshold = stats.distributions.f.ppf(1. - p_threshold / 2.,
n_subjects1 - 1, n_subjects2 - 1)
print('Clustering.')
F_obs, clusters, cluster_p_values, H0 = clu =\
spatio_temporal_cluster_test(
X, adjacency=adjacency, n_jobs=1, n_permutations=n_permutations,
threshold=f_threshold, buffer_size=None)
# Now select the clusters that are sig. at p < 0.05 (note that this value
# is multiple-comparisons corrected).
good_cluster_inds = np.where(cluster_p_values < 0.05)[0]
Explanation: Compute statistic
To use an algorithm optimized for spatio-temporal clustering, we
just pass the spatial adjacency matrix (instead of spatio-temporal)
End of explanation
print('Visualizing clusters.')
# Now let's build a convenient representation of each cluster, where each
# cluster becomes a "time point" in the SourceEstimate
fsave_vertices = [np.arange(10242), np.arange(10242)]
stc_all_cluster_vis = summarize_clusters_stc(clu, tstep=tstep,
vertices=fsave_vertices,
subject='fsaverage')
# Let's actually plot the first "time point" in the SourceEstimate, which
# shows all the clusters, weighted by duration
# blue blobs are for condition A != condition B
brain = stc_all_cluster_vis.plot('fsaverage', hemi='both',
views='lateral', subjects_dir=subjects_dir,
time_label='temporal extent (ms)',
clim=dict(kind='value', lims=[0, 1, 40]))
Explanation: Visualize the clusters
End of explanation |
3,431 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Load new dataset
Step1: Clean and prepare the new dataset
Step2: Import the model from Challenge
Step3: Cross Validation & Predictive Power of the "Challenge | Python Code:
#Load data form excel spreadsheet into pandas
xls_file = pd.ExcelFile('D:\\Users\\Borja.gonzalez\\Desktop\\Thinkful-DataScience-Borja\\Test_fbidata2014.xlsx')
# View the excel file's sheet names
#xls_file.sheet_names
# Load the xls file's 14tbl08ny as a dataframe
testfbi2014 = xls_file.parse('14tbl08ny')
Explanation: Load new dataset
End of explanation
#Transform FBI Raw Data
#Rename columns with row 3 from the original data set
testfbi2014 = testfbi2014.rename(columns=testfbi2014.iloc[3])
#Delete first three rows don´t contain data for the regression model
testfbi2014 = testfbi2014.drop(testfbi2014.index[0:4])
#Delete columns containing "Rape"
testfbi2014 = testfbi2014.drop(['City','Arson3','Rape\n(revised\ndefinition)1','Rape\n(legacy\ndefinition)2'], axis = 1)
#Change names in Columns
testfbi2014 = testfbi2014.rename(columns={'Violent\ncrime': 'Violent Crime', 'Murder and\nnonnegligent\nmanslaughter': 'Murder', 'Robbery': 'Robbery', 'Aggravated\nassault': 'Assault', 'Property\ncrime': 'PropertyCrime', 'Burglary': 'Burglary', 'Larceny-\ntheft': 'Larceny & Theft', 'Motor\nvehicle\ntheft': 'MotorVehicleTheft'})
#Clean NaN values from dataset and reset index
testfbi2014 = testfbi2014.dropna().reset_index(drop=True)
#Convert objects to floats
testfbi2014.astype('float64').info()
#Scale and preprocess the dataset
names = testfbi2014.columns
fbi2014_scaled = pd.DataFrame(preprocessing.scale(testfbi2014), columns = names)
Explanation: Clean and prepare the new dataset
End of explanation
# load the model from disk
filename = 'finalized_regr.sav'
loaded_model = pickle.load(open(filename, 'rb'))
# Inspect the results.
print('\nCoefficients: \n', loaded_model.coef_)
print('\nIntercept: \n', loaded_model.intercept_)
print('\nR-squared:')
print(loaded_model.score(X, Y))
print('\nVariables in the model: \n',list(X.columns))
Explanation: Import the model from Challenge: make your own regression model
End of explanation
X1 = fbi2014_scaled.drop(['Violent Crime','Murder','Larceny & Theft','PropertyCrime','MotorVehicleTheft','Assault'],axis=1)
Y1 = fbi2014_scaled['PropertyCrime'].values.ravel()
#Initiating the cross validation generator, N splits = 10
kf = KFold(20)
#Cross validate the model on the folds
loaded_model.fit(X1,Y1)
scores = cross_val_score(loaded_model, X1, Y1, cv=kf)
print('Cross-validated scores:', scores)
print('Cross-validation average:', scores.mean())
#Predictive accuracy
predictions = cross_val_predict(loaded_model, X1, Y1, cv=kf)
accuracy = metrics.r2_score(Y1, predictions)
print ('Cross-Predicted Accuracy:', accuracy)
# Instantiate and fit our model.
regr1 = linear_model.LinearRegression()
regr1.fit(X1, Y1)
# Inspect the results.
print('\nCoefficients: \n', regr1.coef_)
print('\nIntercept: \n', regr1.intercept_)
print('\nVariables in the model: \n',list(X1.columns))
#Cross validate the new model on the folds
scores = cross_val_score(regr1, X1, Y1, cv=kf)
print('Cross-validated scores:', scores)
print('Cross-validation average:', scores.mean())
#Cross validation, scores
predictions = cross_val_predict(regr1, X1, Y1, cv=kf)
accuracy = metrics.r2_score(Y1, predictions)
print ('Cross-Predicted Accuracy:', accuracy)
# Fit a linear model using Partial Least Squares Regression.
# Reduce feature space to 2 dimensions.
pls1 = PLSRegression(n_components=2)
# Reduce X to R(X) and regress on y.
pls1.fit(X1, Y1)
# Save predicted values.
PLS_predictions = pls1.predict(X1)
print('R-squared PLSR:', pls1.score(X1, Y1))
print('R-squared LR:', scores.mean())
# Compare the predictions of the two models
plt.scatter(predictions,PLS_predictions)
plt.xlabel('Predicted by original 3 features')
plt.ylabel('Predicted by 2 features')
plt.title('Comparing LR and PLSR predictions')
plt.show()
Explanation: Cross Validation & Predictive Power of the "Challenge: make your own regression model" model
End of explanation |
3,432 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Vertex client library
Step1: Install the latest GA version of google-cloud-storage library as well.
Step2: Restart the kernel
Once you've installed the Vertex client library and Google cloud-storage, you need to restart the notebook kernel so it can find the packages.
Step3: Before you begin
GPU runtime
Make sure you're running this notebook in a GPU runtime if you have that option. In Colab, select Runtime > Change Runtime Type > GPU
Set up your Google Cloud project
The following steps are required, regardless of your notebook environment.
Select or create a Google Cloud project. When you first create an account, you get a $300 free credit towards your compute/storage costs.
Make sure that billing is enabled for your project.
Enable the Vertex APIs and Compute Engine APIs.
The Google Cloud SDK is already installed in Google Cloud Notebook.
Enter your project ID in the cell below. Then run the cell to make sure the
Cloud SDK uses the right project for all the commands in this notebook.
Note
Step4: Region
You can also change the REGION variable, which is used for operations
throughout the rest of this notebook. Below are regions supported for Vertex. We recommend that you choose the region closest to you.
Americas
Step5: Timestamp
If you are in a live tutorial session, you might be using a shared test account or project. To avoid name collisions between users on resources created, you create a timestamp for each instance session, and append onto the name of resources which will be created in this tutorial.
Step6: Authenticate your Google Cloud account
If you are using Google Cloud Notebook, your environment is already authenticated. Skip this step.
If you are using Colab, run the cell below and follow the instructions when prompted to authenticate your account via oAuth.
Otherwise, follow these steps
Step7: Create a Cloud Storage bucket
The following steps are required, regardless of your notebook environment.
When you submit a custom training job using the Vertex client library, you upload a Python package
containing your training code to a Cloud Storage bucket. Vertex runs
the code from this package. In this tutorial, Vertex also saves the
trained model that results from your job in the same bucket. You can then
create an Endpoint resource based on this output in order to serve
online predictions.
Set the name of your Cloud Storage bucket below. Bucket names must be globally unique across all Google Cloud projects, including those outside of your organization.
Step8: Only if your bucket doesn't already exist
Step9: Finally, validate access to your Cloud Storage bucket by examining its contents
Step10: Set up variables
Next, set up some variables used throughout the tutorial.
Import libraries and define constants
Import Vertex client library
Import the Vertex client library into our Python environment.
Step11: Vertex constants
Setup up the following constants for Vertex
Step12: Hardware Accelerators
Set the hardware accelerators (e.g., GPU), if any, for training and prediction.
Set the variables TRAIN_GPU/TRAIN_NGPU and DEPLOY_GPU/DEPLOY_NGPU to use a container image supporting a GPU and the number of GPUs allocated to the virtual machine (VM) instance. For example, to use a GPU container image with 4 Nvidia Telsa K80 GPUs allocated to each VM, you would specify
Step13: Container (Docker) image
Next, we will set the Docker container images for training and prediction
TensorFlow 1.15
gcr.io/cloud-aiplatform/training/tf-cpu.1-15
Step14: Machine Type
Next, set the machine type to use for training and prediction.
Set the variables TRAIN_COMPUTE and DEPLOY_COMPUTE to configure the compute resources for the VMs you will use for for training and prediction.
machine type
n1-standard
Step15: Tutorial
Now you are ready to start creating your own custom model and training for IMDB Movie Reviews.
Set up clients
The Vertex client library works as a client/server model. On your side (the Python script) you will create a client that sends requests and receives responses from the Vertex server.
You will use different clients in this tutorial for different steps in the workflow. So set them all up upfront.
Model Service for Model resources.
Endpoint Service for deployment.
Job Service for batch jobs and custom training.
Prediction Service for serving.
Step16: Train a model
There are two ways you can train a custom model using a container image
Step17: Prepare your disk specification
(optional) Now define the disk specification for your custom training job. This tells Vertex what type and size of disk to provision in each machine instance for the training.
boot_disk_type
Step18: Define the worker pool specification
Next, you define the worker pool specification for your custom training job. The worker pool specification will consist of the following
Step19: Assemble a job specification
Now assemble the complete description for the custom job specification
Step20: Examine the training package
Package layout
Before you start the training, you will look at how a Python package is assembled for a custom training job. When unarchived, the package contains the following directory/file layout.
PKG-INFO
README.md
setup.cfg
setup.py
trainer
__init__.py
task.py
The files setup.cfg and setup.py are the instructions for installing the package into the operating environment of the Docker image.
The file trainer/task.py is the Python script for executing the custom training job. Note, when we referred to it in the worker pool specification, we replace the directory slash with a dot (trainer.task) and dropped the file suffix (.py).
Package Assembly
In the following cells, you will assemble the training package.
Step21: Task.py contents
In the next cell, you write the contents of the training script task.py. I won't go into detail, it's just there for you to browse. In summary
Step22: Store training script on your Cloud Storage bucket
Next, you package the training folder into a compressed tar ball, and then store it in your Cloud Storage bucket.
Step23: Train the model
Now start the training of your custom training job on Vertex. Use this helper function create_custom_job, which takes the following parameter
Step24: Now get the unique identifier for the custom job you created.
Step25: Get information on a custom job
Next, use this helper function get_custom_job, which takes the following parameter
Step26: Deployment
Training the above model may take upwards of 20 minutes time.
Once your model is done training, you can calculate the actual time it took to train the model by subtracting end_time from start_time. For your model, we will need to know the location of the saved model, which the Python script saved in your local Cloud Storage bucket at MODEL_DIR + '/saved_model.pb'.
Step27: Load the saved model
Your model is stored in a TensorFlow SavedModel format in a Cloud Storage bucket. Now load it from the Cloud Storage bucket, and then you can do some things, like evaluate the model, and do a prediction.
To load, you use the TF.Keras model.load_model() method passing it the Cloud Storage path where the model is saved -- specified by MODEL_DIR.
Step28: Evaluate the model
Now let's find out how good the model is.
Load evaluation data
You will load the IMDB Movie Review test (holdout) data from tfds.datasets, using the method load(). This will return the dataset as a tuple of two elements. The first element is the dataset and the second is information on the dataset, which will contain the predefined vocabulary encoder. The encoder will convert words into a numerical embedding, which was pretrained and used in the custom training script.
When you trained the model, you needed to set a fix input length for your text. For forward feeding batches, the padded_batch() property of the corresponding tf.dataset was set to pad each input sequence into the same shape for a batch.
For the test data, you also need to set the padded_batch() property accordingly.
Step29: Perform the model evaluation
Now evaluate how well the model in the custom job did.
Step30: Upload the model for serving
Next, you will upload your TF.Keras model from the custom job to Vertex Model service, which will create a Vertex Model resource for your custom model. During upload, you need to define a serving function to convert data to the format your model expects. If you send encoded data to Vertex, your serving function ensures that the data is decoded on the model server before it is passed as input to your model.
How does the serving function work
When you send a request to an online prediction server, the request is received by a HTTP server. The HTTP server extracts the prediction request from the HTTP request content body. The extracted prediction request is forwarded to the serving function. For Google pre-built prediction containers, the request content is passed to the serving function as a tf.string.
The serving function consists of two parts
Step31: Upload the model
Use this helper function upload_model to upload your model, stored in SavedModel format, up to the Model service, which will instantiate a Vertex Model resource instance for your model. Once you've done that, you can use the Model resource instance in the same way as any other Vertex Model resource instance, such as deploying to an Endpoint resource for serving predictions.
The helper function takes the following parameters
Step32: Get Model resource information
Now let's get the model information for just your model. Use this helper function get_model, with the following parameter
Step33: Model deployment for batch prediction
Now deploy the trained Vertex Model resource you created for batch prediction. This differs from deploying a Model resource for on-demand prediction.
For online prediction, you
Step34: Make the batch input file
Now make a batch input file, which you will store in your local Cloud Storage bucket. Each instance in the prediction request is a dictionary entry of the form
Step35: Compute instance scaling
You have several choices on scaling the compute instances for handling your batch prediction requests
Step36: Make batch prediction request
Now that your batch of two test items is ready, let's do the batch request. Use this helper function create_batch_prediction_job, with the following parameters
Step37: Now get the unique identifier for the batch prediction job you created.
Step38: Get information on a batch prediction job
Use this helper function get_batch_prediction_job, with the following paramter
Step40: Get the predictions
When the batch prediction is done processing, the job state will be JOB_STATE_SUCCEEDED.
Finally you view the predictions stored at the Cloud Storage path you set as output. The predictions will be in a JSONL format, which you indicated at the time you made the batch prediction job, under a subfolder starting with the name prediction, and under that folder will be a file called prediction.results-xxxxx-of-xxxxx.
Now display (cat) the contents. You will see multiple JSON objects, one for each prediction.
The response contains a JSON object for each instance, in the form
Step41: Cleaning up
To clean up all GCP resources used in this project, you can delete the GCP
project you used for the tutorial.
Otherwise, you can delete the individual resources you created in this tutorial | Python Code:
import os
import sys
# Google Cloud Notebook
if os.path.exists("/opt/deeplearning/metadata/env_version"):
USER_FLAG = "--user"
else:
USER_FLAG = ""
! pip3 install -U google-cloud-aiplatform $USER_FLAG
Explanation: Vertex client library: Custom training text binary classification model for batch prediction
<table align="left">
<td>
<a href="https://colab.research.google.com/github/GoogleCloudPlatform/vertex-ai-samples/blob/master/notebooks/community/gapic/custom/showcase_custom_text_binary_classification_batch.ipynb">
<img src="https://cloud.google.com/ml-engine/images/colab-logo-32px.png" alt="Colab logo"> Run in Colab
</a>
</td>
<td>
<a href="https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/master/notebooks/community/gapic/custom/showcase_custom_text_binary_classification_batch.ipynb">
<img src="https://cloud.google.com/ml-engine/images/github-logo-32px.png" alt="GitHub logo">
View on GitHub
</a>
</td>
</table>
<br/><br/><br/>
Overview
This tutorial demonstrates how to use the Vertex client library for Python to train and deploy a custom text binary classification model for batch prediction.
Dataset
The dataset used for this tutorial is the IMDB Movie Reviews from TensorFlow Datasets. The version of the dataset you will use in this tutorial is stored in a public Cloud Storage bucket. The trained model predicts whether a review is positive or negative in sentiment.
Objective
In this tutorial, you create a custom model, with a training pipeline, from a Python script in a Google prebuilt Docker container using the Vertex client library, and then do a batch prediction on the uploaded model. You can alternatively create custom models using gcloud command-line tool or online using Google Cloud Console.
The steps performed include:
Create a Vertex custom job for training a model.
Train the TensorFlow model.
Retrieve and load the model artifacts.
View the model evaluation.
Upload the model as a Vertex Model resource.
Make a batch prediction.
Costs
This tutorial uses billable components of Google Cloud (GCP):
Vertex AI
Cloud Storage
Learn about Vertex AI
pricing and Cloud Storage
pricing, and use the Pricing
Calculator
to generate a cost estimate based on your projected usage.
Installation
Install the latest version of Vertex client library.
End of explanation
! pip3 install -U google-cloud-storage $USER_FLAG
Explanation: Install the latest GA version of google-cloud-storage library as well.
End of explanation
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Explanation: Restart the kernel
Once you've installed the Vertex client library and Google cloud-storage, you need to restart the notebook kernel so it can find the packages.
End of explanation
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
if PROJECT_ID == "" or PROJECT_ID is None or PROJECT_ID == "[your-project-id]":
# Get your GCP project id from gcloud
shell_output = !gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID:", PROJECT_ID)
! gcloud config set project $PROJECT_ID
Explanation: Before you begin
GPU runtime
Make sure you're running this notebook in a GPU runtime if you have that option. In Colab, select Runtime > Change Runtime Type > GPU
Set up your Google Cloud project
The following steps are required, regardless of your notebook environment.
Select or create a Google Cloud project. When you first create an account, you get a $300 free credit towards your compute/storage costs.
Make sure that billing is enabled for your project.
Enable the Vertex APIs and Compute Engine APIs.
The Google Cloud SDK is already installed in Google Cloud Notebook.
Enter your project ID in the cell below. Then run the cell to make sure the
Cloud SDK uses the right project for all the commands in this notebook.
Note: Jupyter runs lines prefixed with ! as shell commands, and it interpolates Python variables prefixed with $ into these commands.
End of explanation
REGION = "us-central1" # @param {type: "string"}
Explanation: Region
You can also change the REGION variable, which is used for operations
throughout the rest of this notebook. Below are regions supported for Vertex. We recommend that you choose the region closest to you.
Americas: us-central1
Europe: europe-west4
Asia Pacific: asia-east1
You may not use a multi-regional bucket for training with Vertex. Not all regions provide support for all Vertex services. For the latest support per region, see the Vertex locations documentation
End of explanation
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Explanation: Timestamp
If you are in a live tutorial session, you might be using a shared test account or project. To avoid name collisions between users on resources created, you create a timestamp for each instance session, and append onto the name of resources which will be created in this tutorial.
End of explanation
# If you are running this notebook in Colab, run this cell and follow the
# instructions to authenticate your GCP account. This provides access to your
# Cloud Storage bucket and lets you submit training jobs and prediction
# requests.
# If on Google Cloud Notebook, then don't execute this code
if not os.path.exists("/opt/deeplearning/metadata/env_version"):
if "google.colab" in sys.modules:
from google.colab import auth as google_auth
google_auth.authenticate_user()
# If you are running this notebook locally, replace the string below with the
# path to your service account key and run this cell to authenticate your GCP
# account.
elif not os.getenv("IS_TESTING"):
%env GOOGLE_APPLICATION_CREDENTIALS ''
Explanation: Authenticate your Google Cloud account
If you are using Google Cloud Notebook, your environment is already authenticated. Skip this step.
If you are using Colab, run the cell below and follow the instructions when prompted to authenticate your account via oAuth.
Otherwise, follow these steps:
In the Cloud Console, go to the Create service account key page.
Click Create service account.
In the Service account name field, enter a name, and click Create.
In the Grant this service account access to project section, click the Role drop-down list. Type "Vertex" into the filter box, and select Vertex Administrator. Type "Storage Object Admin" into the filter box, and select Storage Object Admin.
Click Create. A JSON file that contains your key downloads to your local environment.
Enter the path to your service account key as the GOOGLE_APPLICATION_CREDENTIALS variable in the cell below and run the cell.
End of explanation
BUCKET_NAME = "gs://[your-bucket-name]" # @param {type:"string"}
if BUCKET_NAME == "" or BUCKET_NAME is None or BUCKET_NAME == "gs://[your-bucket-name]":
BUCKET_NAME = "gs://" + PROJECT_ID + "aip-" + TIMESTAMP
Explanation: Create a Cloud Storage bucket
The following steps are required, regardless of your notebook environment.
When you submit a custom training job using the Vertex client library, you upload a Python package
containing your training code to a Cloud Storage bucket. Vertex runs
the code from this package. In this tutorial, Vertex also saves the
trained model that results from your job in the same bucket. You can then
create an Endpoint resource based on this output in order to serve
online predictions.
Set the name of your Cloud Storage bucket below. Bucket names must be globally unique across all Google Cloud projects, including those outside of your organization.
End of explanation
! gsutil mb -l $REGION $BUCKET_NAME
Explanation: Only if your bucket doesn't already exist: Run the following cell to create your Cloud Storage bucket.
End of explanation
! gsutil ls -al $BUCKET_NAME
Explanation: Finally, validate access to your Cloud Storage bucket by examining its contents:
End of explanation
import time
from google.cloud.aiplatform import gapic as aip
from google.protobuf import json_format
from google.protobuf.json_format import MessageToJson, ParseDict
from google.protobuf.struct_pb2 import Struct, Value
Explanation: Set up variables
Next, set up some variables used throughout the tutorial.
Import libraries and define constants
Import Vertex client library
Import the Vertex client library into our Python environment.
End of explanation
# API service endpoint
API_ENDPOINT = "{}-aiplatform.googleapis.com".format(REGION)
# Vertex location root path for your dataset, model and endpoint resources
PARENT = "projects/" + PROJECT_ID + "/locations/" + REGION
Explanation: Vertex constants
Setup up the following constants for Vertex:
API_ENDPOINT: The Vertex API service endpoint for dataset, model, job, pipeline and endpoint services.
PARENT: The Vertex location root path for dataset, model, job, pipeline and endpoint resources.
End of explanation
if os.getenv("IS_TESTING_TRAIN_GPU"):
TRAIN_GPU, TRAIN_NGPU = (
aip.AcceleratorType.NVIDIA_TESLA_K80,
int(os.getenv("IS_TESTING_TRAIN_GPU")),
)
else:
TRAIN_GPU, TRAIN_NGPU = (None, None)
if os.getenv("IS_TESTING_DEPOLY_GPU"):
DEPLOY_GPU, DEPLOY_NGPU = (
aip.AcceleratorType.NVIDIA_TESLA_K80,
int(os.getenv("IS_TESTING_DEPOLY_GPU")),
)
else:
DEPLOY_GPU, DEPLOY_NGPU = (None, None)
Explanation: Hardware Accelerators
Set the hardware accelerators (e.g., GPU), if any, for training and prediction.
Set the variables TRAIN_GPU/TRAIN_NGPU and DEPLOY_GPU/DEPLOY_NGPU to use a container image supporting a GPU and the number of GPUs allocated to the virtual machine (VM) instance. For example, to use a GPU container image with 4 Nvidia Telsa K80 GPUs allocated to each VM, you would specify:
(aip.AcceleratorType.NVIDIA_TESLA_K80, 4)
For GPU, available accelerators include:
- aip.AcceleratorType.NVIDIA_TESLA_K80
- aip.AcceleratorType.NVIDIA_TESLA_P100
- aip.AcceleratorType.NVIDIA_TESLA_P4
- aip.AcceleratorType.NVIDIA_TESLA_T4
- aip.AcceleratorType.NVIDIA_TESLA_V100
Otherwise specify (None, None) to use a container image to run on a CPU.
Note: TF releases before 2.3 for GPU support will fail to load the custom model in this tutorial. It is a known issue and fixed in TF 2.3 -- which is caused by static graph ops that are generated in the serving function. If you encounter this issue on your own custom models, use a container image for TF 2.3 with GPU support.
End of explanation
if os.getenv("IS_TESTING_TF"):
TF = os.getenv("IS_TESTING_TF")
else:
TF = "2-1"
if TF[0] == "2":
if TRAIN_GPU:
TRAIN_VERSION = "tf-gpu.{}".format(TF)
else:
TRAIN_VERSION = "tf-cpu.{}".format(TF)
if DEPLOY_GPU:
DEPLOY_VERSION = "tf2-gpu.{}".format(TF)
else:
DEPLOY_VERSION = "tf2-cpu.{}".format(TF)
else:
if TRAIN_GPU:
TRAIN_VERSION = "tf-gpu.{}".format(TF)
else:
TRAIN_VERSION = "tf-cpu.{}".format(TF)
if DEPLOY_GPU:
DEPLOY_VERSION = "tf-gpu.{}".format(TF)
else:
DEPLOY_VERSION = "tf-cpu.{}".format(TF)
TRAIN_IMAGE = "gcr.io/cloud-aiplatform/training/{}:latest".format(TRAIN_VERSION)
DEPLOY_IMAGE = "gcr.io/cloud-aiplatform/prediction/{}:latest".format(DEPLOY_VERSION)
print("Training:", TRAIN_IMAGE, TRAIN_GPU, TRAIN_NGPU)
print("Deployment:", DEPLOY_IMAGE, DEPLOY_GPU, DEPLOY_NGPU)
Explanation: Container (Docker) image
Next, we will set the Docker container images for training and prediction
TensorFlow 1.15
gcr.io/cloud-aiplatform/training/tf-cpu.1-15:latest
gcr.io/cloud-aiplatform/training/tf-gpu.1-15:latest
TensorFlow 2.1
gcr.io/cloud-aiplatform/training/tf-cpu.2-1:latest
gcr.io/cloud-aiplatform/training/tf-gpu.2-1:latest
TensorFlow 2.2
gcr.io/cloud-aiplatform/training/tf-cpu.2-2:latest
gcr.io/cloud-aiplatform/training/tf-gpu.2-2:latest
TensorFlow 2.3
gcr.io/cloud-aiplatform/training/tf-cpu.2-3:latest
gcr.io/cloud-aiplatform/training/tf-gpu.2-3:latest
TensorFlow 2.4
gcr.io/cloud-aiplatform/training/tf-cpu.2-4:latest
gcr.io/cloud-aiplatform/training/tf-gpu.2-4:latest
XGBoost
gcr.io/cloud-aiplatform/training/xgboost-cpu.1-1
Scikit-learn
gcr.io/cloud-aiplatform/training/scikit-learn-cpu.0-23:latest
Pytorch
gcr.io/cloud-aiplatform/training/pytorch-cpu.1-4:latest
gcr.io/cloud-aiplatform/training/pytorch-cpu.1-5:latest
gcr.io/cloud-aiplatform/training/pytorch-cpu.1-6:latest
gcr.io/cloud-aiplatform/training/pytorch-cpu.1-7:latest
For the latest list, see Pre-built containers for training.
TensorFlow 1.15
gcr.io/cloud-aiplatform/prediction/tf-cpu.1-15:latest
gcr.io/cloud-aiplatform/prediction/tf-gpu.1-15:latest
TensorFlow 2.1
gcr.io/cloud-aiplatform/prediction/tf2-cpu.2-1:latest
gcr.io/cloud-aiplatform/prediction/tf2-gpu.2-1:latest
TensorFlow 2.2
gcr.io/cloud-aiplatform/prediction/tf2-cpu.2-2:latest
gcr.io/cloud-aiplatform/prediction/tf2-gpu.2-2:latest
TensorFlow 2.3
gcr.io/cloud-aiplatform/prediction/tf2-cpu.2-3:latest
gcr.io/cloud-aiplatform/prediction/tf2-gpu.2-3:latest
XGBoost
gcr.io/cloud-aiplatform/prediction/xgboost-cpu.1-2:latest
gcr.io/cloud-aiplatform/prediction/xgboost-cpu.1-1:latest
gcr.io/cloud-aiplatform/prediction/xgboost-cpu.0-90:latest
gcr.io/cloud-aiplatform/prediction/xgboost-cpu.0-82:latest
Scikit-learn
gcr.io/cloud-aiplatform/prediction/sklearn-cpu.0-23:latest
gcr.io/cloud-aiplatform/prediction/sklearn-cpu.0-22:latest
gcr.io/cloud-aiplatform/prediction/sklearn-cpu.0-20:latest
For the latest list, see Pre-built containers for prediction
End of explanation
if os.getenv("IS_TESTING_TRAIN_MACHINE"):
MACHINE_TYPE = os.getenv("IS_TESTING_TRAIN_MACHINE")
else:
MACHINE_TYPE = "n1-standard"
VCPU = "4"
TRAIN_COMPUTE = MACHINE_TYPE + "-" + VCPU
print("Train machine type", TRAIN_COMPUTE)
if os.getenv("IS_TESTING_DEPLOY_MACHINE"):
MACHINE_TYPE = os.getenv("IS_TESTING_DEPLOY_MACHINE")
else:
MACHINE_TYPE = "n1-standard"
VCPU = "4"
DEPLOY_COMPUTE = MACHINE_TYPE + "-" + VCPU
print("Deploy machine type", DEPLOY_COMPUTE)
Explanation: Machine Type
Next, set the machine type to use for training and prediction.
Set the variables TRAIN_COMPUTE and DEPLOY_COMPUTE to configure the compute resources for the VMs you will use for for training and prediction.
machine type
n1-standard: 3.75GB of memory per vCPU.
n1-highmem: 6.5GB of memory per vCPU
n1-highcpu: 0.9 GB of memory per vCPU
vCPUs: number of [2, 4, 8, 16, 32, 64, 96 ]
Note: The following is not supported for training:
standard: 2 vCPUs
highcpu: 2, 4 and 8 vCPUs
Note: You may also use n2 and e2 machine types for training and deployment, but they do not support GPUs.
End of explanation
# client options same for all services
client_options = {"api_endpoint": API_ENDPOINT}
def create_job_client():
client = aip.JobServiceClient(client_options=client_options)
return client
def create_model_client():
client = aip.ModelServiceClient(client_options=client_options)
return client
def create_endpoint_client():
client = aip.EndpointServiceClient(client_options=client_options)
return client
def create_prediction_client():
client = aip.PredictionServiceClient(client_options=client_options)
return client
clients = {}
clients["job"] = create_job_client()
clients["model"] = create_model_client()
clients["endpoint"] = create_endpoint_client()
clients["prediction"] = create_prediction_client()
for client in clients.items():
print(client)
Explanation: Tutorial
Now you are ready to start creating your own custom model and training for IMDB Movie Reviews.
Set up clients
The Vertex client library works as a client/server model. On your side (the Python script) you will create a client that sends requests and receives responses from the Vertex server.
You will use different clients in this tutorial for different steps in the workflow. So set them all up upfront.
Model Service for Model resources.
Endpoint Service for deployment.
Job Service for batch jobs and custom training.
Prediction Service for serving.
End of explanation
if TRAIN_GPU:
machine_spec = {
"machine_type": TRAIN_COMPUTE,
"accelerator_type": TRAIN_GPU,
"accelerator_count": TRAIN_NGPU,
}
else:
machine_spec = {"machine_type": TRAIN_COMPUTE, "accelerator_count": 0}
Explanation: Train a model
There are two ways you can train a custom model using a container image:
Use a Google Cloud prebuilt container. If you use a prebuilt container, you will additionally specify a Python package to install into the container image. This Python package contains your code for training a custom model.
Use your own custom container image. If you use your own container, the container needs to contain your code for training a custom model.
Prepare your custom job specification
Now that your clients are ready, your first step is to create a Job Specification for your custom training job. The job specification will consist of the following:
worker_pool_spec : The specification of the type of machine(s) you will use for training and how many (single or distributed)
python_package_spec : The specification of the Python package to be installed with the pre-built container.
Prepare your machine specification
Now define the machine specification for your custom training job. This tells Vertex what type of machine instance to provision for the training.
- machine_type: The type of GCP instance to provision -- e.g., n1-standard-8.
- accelerator_type: The type, if any, of hardware accelerator. In this tutorial if you previously set the variable TRAIN_GPU != None, you are using a GPU; otherwise you will use a CPU.
- accelerator_count: The number of accelerators.
End of explanation
DISK_TYPE = "pd-ssd" # [ pd-ssd, pd-standard]
DISK_SIZE = 200 # GB
disk_spec = {"boot_disk_type": DISK_TYPE, "boot_disk_size_gb": DISK_SIZE}
Explanation: Prepare your disk specification
(optional) Now define the disk specification for your custom training job. This tells Vertex what type and size of disk to provision in each machine instance for the training.
boot_disk_type: Either SSD or Standard. SSD is faster, and Standard is less expensive. Defaults to SSD.
boot_disk_size_gb: Size of disk in GB.
End of explanation
JOB_NAME = "custom_job_" + TIMESTAMP
MODEL_DIR = "{}/{}".format(BUCKET_NAME, JOB_NAME)
if not TRAIN_NGPU or TRAIN_NGPU < 2:
TRAIN_STRATEGY = "single"
else:
TRAIN_STRATEGY = "mirror"
EPOCHS = 20
STEPS = 100
DIRECT = True
if DIRECT:
CMDARGS = [
"--model-dir=" + MODEL_DIR,
"--epochs=" + str(EPOCHS),
"--steps=" + str(STEPS),
"--distribute=" + TRAIN_STRATEGY,
]
else:
CMDARGS = [
"--epochs=" + str(EPOCHS),
"--steps=" + str(STEPS),
"--distribute=" + TRAIN_STRATEGY,
]
worker_pool_spec = [
{
"replica_count": 1,
"machine_spec": machine_spec,
"disk_spec": disk_spec,
"python_package_spec": {
"executor_image_uri": TRAIN_IMAGE,
"package_uris": [BUCKET_NAME + "/trainer_imdb.tar.gz"],
"python_module": "trainer.task",
"args": CMDARGS,
},
}
]
Explanation: Define the worker pool specification
Next, you define the worker pool specification for your custom training job. The worker pool specification will consist of the following:
replica_count: The number of instances to provision of this machine type.
machine_spec: The hardware specification.
disk_spec : (optional) The disk storage specification.
python_package: The Python training package to install on the VM instance(s) and which Python module to invoke, along with command line arguments for the Python module.
Let's dive deeper now into the python package specification:
-executor_image_spec: This is the docker image which is configured for your custom training job.
-package_uris: This is a list of the locations (URIs) of your python training packages to install on the provisioned instance. The locations need to be in a Cloud Storage bucket. These can be either individual python files or a zip (archive) of an entire package. In the later case, the job service will unzip (unarchive) the contents into the docker image.
-python_module: The Python module (script) to invoke for running the custom training job. In this example, you will be invoking trainer.task.py -- note that it was not neccessary to append the .py suffix.
-args: The command line arguments to pass to the corresponding Pythom module. In this example, you will be setting:
- "--model-dir=" + MODEL_DIR : The Cloud Storage location where to store the model artifacts. There are two ways to tell the training script where to save the model artifacts:
- direct: You pass the Cloud Storage location as a command line argument to your training script (set variable DIRECT = True), or
- indirect: The service passes the Cloud Storage location as the environment variable AIP_MODEL_DIR to your training script (set variable DIRECT = False). In this case, you tell the service the model artifact location in the job specification.
- "--epochs=" + EPOCHS: The number of epochs for training.
- "--steps=" + STEPS: The number of steps (batches) per epoch.
- "--distribute=" + TRAIN_STRATEGY" : The training distribution strategy to use for single or distributed training.
- "single": single device.
- "mirror": all GPU devices on a single compute instance.
- "multi": all GPU devices on all compute instances.
End of explanation
if DIRECT:
job_spec = {"worker_pool_specs": worker_pool_spec}
else:
job_spec = {
"worker_pool_specs": worker_pool_spec,
"base_output_directory": {"output_uri_prefix": MODEL_DIR},
}
custom_job = {"display_name": JOB_NAME, "job_spec": job_spec}
Explanation: Assemble a job specification
Now assemble the complete description for the custom job specification:
display_name: The human readable name you assign to this custom job.
job_spec: The specification for the custom job.
worker_pool_specs: The specification for the machine VM instances.
base_output_directory: This tells the service the Cloud Storage location where to save the model artifacts (when variable DIRECT = False). The service will then pass the location to the training script as the environment variable AIP_MODEL_DIR, and the path will be of the form: <output_uri_prefix>/model
End of explanation
# Make folder for Python training script
! rm -rf custom
! mkdir custom
# Add package information
! touch custom/README.md
setup_cfg = "[egg_info]\n\ntag_build =\n\ntag_date = 0"
! echo "$setup_cfg" > custom/setup.cfg
setup_py = "import setuptools\n\nsetuptools.setup(\n\n install_requires=[\n\n 'tensorflow_datasets==1.3.0',\n\n ],\n\n packages=setuptools.find_packages())"
! echo "$setup_py" > custom/setup.py
pkg_info = "Metadata-Version: 1.0\n\nName: IMDB Movie Reviews text binary classification\n\nVersion: 0.0.0\n\nSummary: Demostration training script\n\nHome-page: www.google.com\n\nAuthor: Google\n\nAuthor-email: [email protected]\n\nLicense: Public\n\nDescription: Demo\n\nPlatform: Vertex"
! echo "$pkg_info" > custom/PKG-INFO
# Make the training subfolder
! mkdir custom/trainer
! touch custom/trainer/__init__.py
Explanation: Examine the training package
Package layout
Before you start the training, you will look at how a Python package is assembled for a custom training job. When unarchived, the package contains the following directory/file layout.
PKG-INFO
README.md
setup.cfg
setup.py
trainer
__init__.py
task.py
The files setup.cfg and setup.py are the instructions for installing the package into the operating environment of the Docker image.
The file trainer/task.py is the Python script for executing the custom training job. Note, when we referred to it in the worker pool specification, we replace the directory slash with a dot (trainer.task) and dropped the file suffix (.py).
Package Assembly
In the following cells, you will assemble the training package.
End of explanation
%%writefile custom/trainer/task.py
# Single, Mirror and Multi-Machine Distributed Training for IMDB
import tensorflow_datasets as tfds
import tensorflow as tf
from tensorflow.python.client import device_lib
import argparse
import os
import sys
tfds.disable_progress_bar()
parser = argparse.ArgumentParser()
parser.add_argument('--model-dir', dest='model_dir',
default=os.getenv('AIP_MODEL_DIR'), type=str, help='Model dir.')
parser.add_argument('--lr', dest='lr',
default=1e-4, type=float,
help='Learning rate.')
parser.add_argument('--epochs', dest='epochs',
default=20, type=int,
help='Number of epochs.')
parser.add_argument('--steps', dest='steps',
default=100, type=int,
help='Number of steps per epoch.')
parser.add_argument('--distribute', dest='distribute', type=str, default='single',
help='distributed training strategy')
args = parser.parse_args()
print('Python Version = {}'.format(sys.version))
print('TensorFlow Version = {}'.format(tf.__version__))
print('TF_CONFIG = {}'.format(os.environ.get('TF_CONFIG', 'Not found')))
print(device_lib.list_local_devices())
# Single Machine, single compute device
if args.distribute == 'single':
if tf.test.is_gpu_available():
strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
else:
strategy = tf.distribute.OneDeviceStrategy(device="/cpu:0")
# Single Machine, multiple compute device
elif args.distribute == 'mirror':
strategy = tf.distribute.MirroredStrategy()
# Multiple Machine, multiple compute device
elif args.distribute == 'multi':
strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
# Multi-worker configuration
print('num_replicas_in_sync = {}'.format(strategy.num_replicas_in_sync))
# Preparing dataset
BUFFER_SIZE = 10000
BATCH_SIZE = 64
def make_datasets():
dataset, info = tfds.load('imdb_reviews/subwords8k', with_info=True,
as_supervised=True)
train_dataset, test_dataset = dataset['train'], dataset['test']
encoder = info.features['text'].encoder
padded_shapes = ([None],())
return train_dataset.shuffle(BUFFER_SIZE).padded_batch(BATCH_SIZE, padded_shapes), encoder
train_dataset, encoder = make_datasets()
# Build the Keras model
def build_and_compile_rnn_model(encoder):
model = tf.keras.Sequential([
tf.keras.layers.Embedding(encoder.vocab_size, 64),
tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64)),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
optimizer=tf.keras.optimizers.Adam(args.lr),
metrics=['accuracy'])
return model
with strategy.scope():
# Creation of dataset, and model building/compiling need to be within
# `strategy.scope()`.
model = build_and_compile_rnn_model(encoder)
# Train the model
model.fit(train_dataset, epochs=args.epochs, steps_per_epoch=args.steps)
model.save(args.model_dir)
Explanation: Task.py contents
In the next cell, you write the contents of the training script task.py. I won't go into detail, it's just there for you to browse. In summary:
Gets the directory where to save the model artifacts from the command line (--model_dir), and if not specified, then from the environment variable AIP_MODEL_DIR.
Loads IMDB Movie Reviews dataset from TF Datasets (tfds).
Builds a simple RNN model using TF.Keras model API.
Compiles the model (compile()).
Sets a training distribution strategy according to the argument args.distribute.
Trains the model (fit()) with epochs specified by args.epochs.
Saves the trained model (save(args.model_dir)) to the specified model directory.
End of explanation
! rm -f custom.tar custom.tar.gz
! tar cvf custom.tar custom
! gzip custom.tar
! gsutil cp custom.tar.gz $BUCKET_NAME/trainer_imdb.tar.gz
Explanation: Store training script on your Cloud Storage bucket
Next, you package the training folder into a compressed tar ball, and then store it in your Cloud Storage bucket.
End of explanation
def create_custom_job(custom_job):
response = clients["job"].create_custom_job(parent=PARENT, custom_job=custom_job)
print("name:", response.name)
print("display_name:", response.display_name)
print("state:", response.state)
print("create_time:", response.create_time)
print("update_time:", response.update_time)
return response
response = create_custom_job(custom_job)
Explanation: Train the model
Now start the training of your custom training job on Vertex. Use this helper function create_custom_job, which takes the following parameter:
-custom_job: The specification for the custom job.
The helper function calls job client service's create_custom_job method, with the following parameters:
-parent: The Vertex location path to Dataset, Model and Endpoint resources.
-custom_job: The specification for the custom job.
You will display a handful of the fields returned in response object, with the two that are of most interest are:
response.name: The Vertex fully qualified identifier assigned to this custom training job. You save this identifier for using in subsequent steps.
response.state: The current state of the custom training job.
End of explanation
# The full unique ID for the custom job
job_id = response.name
# The short numeric ID for the custom job
job_short_id = job_id.split("/")[-1]
print(job_id)
Explanation: Now get the unique identifier for the custom job you created.
End of explanation
def get_custom_job(name, silent=False):
response = clients["job"].get_custom_job(name=name)
if silent:
return response
print("name:", response.name)
print("display_name:", response.display_name)
print("state:", response.state)
print("create_time:", response.create_time)
print("update_time:", response.update_time)
return response
response = get_custom_job(job_id)
Explanation: Get information on a custom job
Next, use this helper function get_custom_job, which takes the following parameter:
name: The Vertex fully qualified identifier for the custom job.
The helper function calls the job client service'sget_custom_job method, with the following parameter:
name: The Vertex fully qualified identifier for the custom job.
If you recall, you got the Vertex fully qualified identifier for the custom job in the response.name field when you called the create_custom_job method, and saved the identifier in the variable job_id.
End of explanation
while True:
response = get_custom_job(job_id, True)
if response.state != aip.JobState.JOB_STATE_SUCCEEDED:
print("Training job has not completed:", response.state)
model_path_to_deploy = None
if response.state == aip.JobState.JOB_STATE_FAILED:
break
else:
if not DIRECT:
MODEL_DIR = MODEL_DIR + "/model"
model_path_to_deploy = MODEL_DIR
print("Training Time:", response.update_time - response.create_time)
break
time.sleep(60)
print("model_to_deploy:", model_path_to_deploy)
Explanation: Deployment
Training the above model may take upwards of 20 minutes time.
Once your model is done training, you can calculate the actual time it took to train the model by subtracting end_time from start_time. For your model, we will need to know the location of the saved model, which the Python script saved in your local Cloud Storage bucket at MODEL_DIR + '/saved_model.pb'.
End of explanation
import tensorflow as tf
model = tf.keras.models.load_model(MODEL_DIR)
Explanation: Load the saved model
Your model is stored in a TensorFlow SavedModel format in a Cloud Storage bucket. Now load it from the Cloud Storage bucket, and then you can do some things, like evaluate the model, and do a prediction.
To load, you use the TF.Keras model.load_model() method passing it the Cloud Storage path where the model is saved -- specified by MODEL_DIR.
End of explanation
import tensorflow_datasets as tfds
dataset, info = tfds.load("imdb_reviews/subwords8k", with_info=True, as_supervised=True)
test_dataset = dataset["test"]
encoder = info.features["text"].encoder
BATCH_SIZE = 64
padded_shapes = ([None], ())
test_dataset = test_dataset.padded_batch(BATCH_SIZE, padded_shapes)
Explanation: Evaluate the model
Now let's find out how good the model is.
Load evaluation data
You will load the IMDB Movie Review test (holdout) data from tfds.datasets, using the method load(). This will return the dataset as a tuple of two elements. The first element is the dataset and the second is information on the dataset, which will contain the predefined vocabulary encoder. The encoder will convert words into a numerical embedding, which was pretrained and used in the custom training script.
When you trained the model, you needed to set a fix input length for your text. For forward feeding batches, the padded_batch() property of the corresponding tf.dataset was set to pad each input sequence into the same shape for a batch.
For the test data, you also need to set the padded_batch() property accordingly.
End of explanation
model.evaluate(test_dataset)
Explanation: Perform the model evaluation
Now evaluate how well the model in the custom job did.
End of explanation
loaded = tf.saved_model.load(model_path_to_deploy)
serving_input = list(
loaded.signatures["serving_default"].structured_input_signature[1].keys()
)[0]
print("Serving function input:", serving_input)
Explanation: Upload the model for serving
Next, you will upload your TF.Keras model from the custom job to Vertex Model service, which will create a Vertex Model resource for your custom model. During upload, you need to define a serving function to convert data to the format your model expects. If you send encoded data to Vertex, your serving function ensures that the data is decoded on the model server before it is passed as input to your model.
How does the serving function work
When you send a request to an online prediction server, the request is received by a HTTP server. The HTTP server extracts the prediction request from the HTTP request content body. The extracted prediction request is forwarded to the serving function. For Google pre-built prediction containers, the request content is passed to the serving function as a tf.string.
The serving function consists of two parts:
preprocessing function:
Converts the input (tf.string) to the input shape and data type of the underlying model (dynamic graph).
Performs the same preprocessing of the data that was done during training the underlying model -- e.g., normalizing, scaling, etc.
post-processing function:
Converts the model output to format expected by the receiving application -- e.q., compresses the output.
Packages the output for the the receiving application -- e.g., add headings, make JSON object, etc.
Both the preprocessing and post-processing functions are converted to static graphs which are fused to the model. The output from the underlying model is passed to the post-processing function. The post-processing function passes the converted/packaged output back to the HTTP server. The HTTP server returns the output as the HTTP response content.
One consideration you need to consider when building serving functions for TF.Keras models is that they run as static graphs. That means, you cannot use TF graph operations that require a dynamic graph. If you do, you will get an error during the compile of the serving function which will indicate that you are using an EagerTensor which is not supported.
Get the serving function signature
You can get the signatures of your model's input and output layers by reloading the model into memory, and querying it for the signatures corresponding to each layer.
When making a prediction request, you need to route the request to the serving function instead of the model, so you need to know the input layer name of the serving function -- which you will use later when you make a prediction request.
End of explanation
IMAGE_URI = DEPLOY_IMAGE
def upload_model(display_name, image_uri, model_uri):
model = {
"display_name": display_name,
"metadata_schema_uri": "",
"artifact_uri": model_uri,
"container_spec": {
"image_uri": image_uri,
"command": [],
"args": [],
"env": [{"name": "env_name", "value": "env_value"}],
"ports": [{"container_port": 8080}],
"predict_route": "",
"health_route": "",
},
}
response = clients["model"].upload_model(parent=PARENT, model=model)
print("Long running operation:", response.operation.name)
upload_model_response = response.result(timeout=180)
print("upload_model_response")
print(" model:", upload_model_response.model)
return upload_model_response.model
model_to_deploy_id = upload_model("imdb-" + TIMESTAMP, IMAGE_URI, model_path_to_deploy)
Explanation: Upload the model
Use this helper function upload_model to upload your model, stored in SavedModel format, up to the Model service, which will instantiate a Vertex Model resource instance for your model. Once you've done that, you can use the Model resource instance in the same way as any other Vertex Model resource instance, such as deploying to an Endpoint resource for serving predictions.
The helper function takes the following parameters:
display_name: A human readable name for the Endpoint service.
image_uri: The container image for the model deployment.
model_uri: The Cloud Storage path to our SavedModel artificat. For this tutorial, this is the Cloud Storage location where the trainer/task.py saved the model artifacts, which we specified in the variable MODEL_DIR.
The helper function calls the Model client service's method upload_model, which takes the following parameters:
parent: The Vertex location root path for Dataset, Model and Endpoint resources.
model: The specification for the Vertex Model resource instance.
Let's now dive deeper into the Vertex model specification model. This is a dictionary object that consists of the following fields:
display_name: A human readable name for the Model resource.
metadata_schema_uri: Since your model was built without an Vertex Dataset resource, you will leave this blank ('').
artificat_uri: The Cloud Storage path where the model is stored in SavedModel format.
container_spec: This is the specification for the Docker container that will be installed on the Endpoint resource, from which the Model resource will serve predictions. Use the variable you set earlier DEPLOY_GPU != None to use a GPU; otherwise only a CPU is allocated.
Uploading a model into a Vertex Model resource returns a long running operation, since it may take a few moments. You call response.result(), which is a synchronous call and will return when the Vertex Model resource is ready.
The helper function returns the Vertex fully qualified identifier for the corresponding Vertex Model instance upload_model_response.model. You will save the identifier for subsequent steps in the variable model_to_deploy_id.
End of explanation
def get_model(name):
response = clients["model"].get_model(name=name)
print(response)
get_model(model_to_deploy_id)
Explanation: Get Model resource information
Now let's get the model information for just your model. Use this helper function get_model, with the following parameter:
name: The Vertex unique identifier for the Model resource.
This helper function calls the Vertex Model client service's method get_model, with the following parameter:
name: The Vertex unique identifier for the Model resource.
End of explanation
import tensorflow_datasets as tfds
dataset, info = tfds.load("imdb_reviews/subwords8k", with_info=True, as_supervised=True)
test_dataset = dataset["test"]
test_dataset.take(1)
for data in test_dataset:
print(data)
break
test_item = data[0].numpy()
Explanation: Model deployment for batch prediction
Now deploy the trained Vertex Model resource you created for batch prediction. This differs from deploying a Model resource for on-demand prediction.
For online prediction, you:
Create an Endpoint resource for deploying the Model resource to.
Deploy the Model resource to the Endpoint resource.
Make online prediction requests to the Endpoint resource.
For batch-prediction, you:
Create a batch prediction job.
The job service will provision resources for the batch prediction request.
The results of the batch prediction request are returned to the caller.
The job service will unprovision the resoures for the batch prediction request.
Make a batch prediction request
Now do a batch prediction to your deployed model.
Prepare the request content
Since the dataset is a tf.dataset, which acts as a generator, we must use it as an iterator to access the data items in the test data. We do the following to get a single data item from the test data:
Set the property for the number of batches to draw per iteration to one using the method take(1).
Iterate once through the test data -- i.e., we do a break within the for loop.
In the single iteration, we save the data item which is in the form of a tuple.
The data item will be the first element of the tuple, which you then will convert from an tensor to a numpy array -- data[0].numpy().
End of explanation
import json
gcs_input_uri = BUCKET_NAME + "/" + "test.jsonl"
with tf.io.gfile.GFile(gcs_input_uri, "w") as f:
data = {serving_input: test_item.tolist()}
f.write(json.dumps(data) + "\n")
Explanation: Make the batch input file
Now make a batch input file, which you will store in your local Cloud Storage bucket. Each instance in the prediction request is a dictionary entry of the form:
{serving_input: content}
input_name: the name of the input layer of the underlying model.
content: The text data item encoded as an embedding.
End of explanation
MIN_NODES = 1
MAX_NODES = 1
Explanation: Compute instance scaling
You have several choices on scaling the compute instances for handling your batch prediction requests:
Single Instance: The batch prediction requests are processed on a single compute instance.
Set the minimum (MIN_NODES) and maximum (MAX_NODES) number of compute instances to one.
Manual Scaling: The batch prediction requests are split across a fixed number of compute instances that you manually specified.
Set the minimum (MIN_NODES) and maximum (MAX_NODES) number of compute instances to the same number of nodes. When a model is first deployed to the instance, the fixed number of compute instances are provisioned and batch prediction requests are evenly distributed across them.
Auto Scaling: The batch prediction requests are split across a scaleable number of compute instances.
Set the minimum (MIN_NODES) number of compute instances to provision when a model is first deployed and to de-provision, and set the maximum (`MAX_NODES) number of compute instances to provision, depending on load conditions.
The minimum number of compute instances corresponds to the field min_replica_count and the maximum number of compute instances corresponds to the field max_replica_count, in your subsequent deployment request.
End of explanation
BATCH_MODEL = "imdb_batch-" + TIMESTAMP
def create_batch_prediction_job(
display_name,
model_name,
gcs_source_uri,
gcs_destination_output_uri_prefix,
parameters=None,
):
if DEPLOY_GPU:
machine_spec = {
"machine_type": DEPLOY_COMPUTE,
"accelerator_type": DEPLOY_GPU,
"accelerator_count": DEPLOY_NGPU,
}
else:
machine_spec = {
"machine_type": DEPLOY_COMPUTE,
"accelerator_count": 0,
}
batch_prediction_job = {
"display_name": display_name,
# Format: 'projects/{project}/locations/{location}/models/{model_id}'
"model": model_name,
"model_parameters": json_format.ParseDict(parameters, Value()),
"input_config": {
"instances_format": IN_FORMAT,
"gcs_source": {"uris": [gcs_source_uri]},
},
"output_config": {
"predictions_format": OUT_FORMAT,
"gcs_destination": {"output_uri_prefix": gcs_destination_output_uri_prefix},
},
"dedicated_resources": {
"machine_spec": machine_spec,
"starting_replica_count": MIN_NODES,
"max_replica_count": MAX_NODES,
},
}
response = clients["job"].create_batch_prediction_job(
parent=PARENT, batch_prediction_job=batch_prediction_job
)
print("response")
print(" name:", response.name)
print(" display_name:", response.display_name)
print(" model:", response.model)
try:
print(" generate_explanation:", response.generate_explanation)
except:
pass
print(" state:", response.state)
print(" create_time:", response.create_time)
print(" start_time:", response.start_time)
print(" end_time:", response.end_time)
print(" update_time:", response.update_time)
print(" labels:", response.labels)
return response
IN_FORMAT = "jsonl"
OUT_FORMAT = "jsonl"
response = create_batch_prediction_job(
BATCH_MODEL, model_to_deploy_id, gcs_input_uri, BUCKET_NAME
)
Explanation: Make batch prediction request
Now that your batch of two test items is ready, let's do the batch request. Use this helper function create_batch_prediction_job, with the following parameters:
display_name: The human readable name for the prediction job.
model_name: The Vertex fully qualified identifier for the Model resource.
gcs_source_uri: The Cloud Storage path to the input file -- which you created above.
gcs_destination_output_uri_prefix: The Cloud Storage path that the service will write the predictions to.
parameters: Additional filtering parameters for serving prediction results.
The helper function calls the job client service's create_batch_prediction_job metho, with the following parameters:
parent: The Vertex location root path for Dataset, Model and Pipeline resources.
batch_prediction_job: The specification for the batch prediction job.
Let's now dive into the specification for the batch_prediction_job:
display_name: The human readable name for the prediction batch job.
model: The Vertex fully qualified identifier for the Model resource.
dedicated_resources: The compute resources to provision for the batch prediction job.
machine_spec: The compute instance to provision. Use the variable you set earlier DEPLOY_GPU != None to use a GPU; otherwise only a CPU is allocated.
starting_replica_count: The number of compute instances to initially provision, which you set earlier as the variable MIN_NODES.
max_replica_count: The maximum number of compute instances to scale to, which you set earlier as the variable MAX_NODES.
model_parameters: Additional filtering parameters for serving prediction results. No Additional parameters are supported for custom models.
input_config: The input source and format type for the instances to predict.
instances_format: The format of the batch prediction request file: csv or jsonl.
gcs_source: A list of one or more Cloud Storage paths to your batch prediction requests.
output_config: The output destination and format for the predictions.
prediction_format: The format of the batch prediction response file: csv or jsonl.
gcs_destination: The output destination for the predictions.
This call is an asychronous operation. You will print from the response object a few select fields, including:
name: The Vertex fully qualified identifier assigned to the batch prediction job.
display_name: The human readable name for the prediction batch job.
model: The Vertex fully qualified identifier for the Model resource.
generate_explanations: Whether True/False explanations were provided with the predictions (explainability).
state: The state of the prediction job (pending, running, etc).
Since this call will take a few moments to execute, you will likely get JobState.JOB_STATE_PENDING for state.
End of explanation
# The full unique ID for the batch job
batch_job_id = response.name
# The short numeric ID for the batch job
batch_job_short_id = batch_job_id.split("/")[-1]
print(batch_job_id)
Explanation: Now get the unique identifier for the batch prediction job you created.
End of explanation
def get_batch_prediction_job(job_name, silent=False):
response = clients["job"].get_batch_prediction_job(name=job_name)
if silent:
return response.output_config.gcs_destination.output_uri_prefix, response.state
print("response")
print(" name:", response.name)
print(" display_name:", response.display_name)
print(" model:", response.model)
try: # not all data types support explanations
print(" generate_explanation:", response.generate_explanation)
except:
pass
print(" state:", response.state)
print(" error:", response.error)
gcs_destination = response.output_config.gcs_destination
print(" gcs_destination")
print(" output_uri_prefix:", gcs_destination.output_uri_prefix)
return gcs_destination.output_uri_prefix, response.state
predictions, state = get_batch_prediction_job(batch_job_id)
Explanation: Get information on a batch prediction job
Use this helper function get_batch_prediction_job, with the following paramter:
job_name: The Vertex fully qualified identifier for the batch prediction job.
The helper function calls the job client service's get_batch_prediction_job method, with the following paramter:
name: The Vertex fully qualified identifier for the batch prediction job. In this tutorial, you will pass it the Vertex fully qualified identifier for your batch prediction job -- batch_job_id
The helper function will return the Cloud Storage path to where the predictions are stored -- gcs_destination.
End of explanation
def get_latest_predictions(gcs_out_dir):
Get the latest prediction subfolder using the timestamp in the subfolder name
folders = !gsutil ls $gcs_out_dir
latest = ""
for folder in folders:
subfolder = folder.split("/")[-2]
if subfolder.startswith("prediction-"):
if subfolder > latest:
latest = folder[:-1]
return latest
while True:
predictions, state = get_batch_prediction_job(batch_job_id, True)
if state != aip.JobState.JOB_STATE_SUCCEEDED:
print("The job has not completed:", state)
if state == aip.JobState.JOB_STATE_FAILED:
raise Exception("Batch Job Failed")
else:
folder = get_latest_predictions(predictions)
! gsutil ls $folder/prediction.results*
print("Results:")
! gsutil cat $folder/prediction.results*
print("Errors:")
! gsutil cat $folder/prediction.errors*
break
time.sleep(60)
Explanation: Get the predictions
When the batch prediction is done processing, the job state will be JOB_STATE_SUCCEEDED.
Finally you view the predictions stored at the Cloud Storage path you set as output. The predictions will be in a JSONL format, which you indicated at the time you made the batch prediction job, under a subfolder starting with the name prediction, and under that folder will be a file called prediction.results-xxxxx-of-xxxxx.
Now display (cat) the contents. You will see multiple JSON objects, one for each prediction.
The response contains a JSON object for each instance, in the form:
embedding_input: The input for the prediction.
predictions -- the predicated binary sentiment between 0 (negative) and 1 (positive).
End of explanation
delete_dataset = True
delete_pipeline = True
delete_model = True
delete_endpoint = True
delete_batchjob = True
delete_customjob = True
delete_hptjob = True
delete_bucket = True
# Delete the dataset using the Vertex fully qualified identifier for the dataset
try:
if delete_dataset and "dataset_id" in globals():
clients["dataset"].delete_dataset(name=dataset_id)
except Exception as e:
print(e)
# Delete the training pipeline using the Vertex fully qualified identifier for the pipeline
try:
if delete_pipeline and "pipeline_id" in globals():
clients["pipeline"].delete_training_pipeline(name=pipeline_id)
except Exception as e:
print(e)
# Delete the model using the Vertex fully qualified identifier for the model
try:
if delete_model and "model_to_deploy_id" in globals():
clients["model"].delete_model(name=model_to_deploy_id)
except Exception as e:
print(e)
# Delete the endpoint using the Vertex fully qualified identifier for the endpoint
try:
if delete_endpoint and "endpoint_id" in globals():
clients["endpoint"].delete_endpoint(name=endpoint_id)
except Exception as e:
print(e)
# Delete the batch job using the Vertex fully qualified identifier for the batch job
try:
if delete_batchjob and "batch_job_id" in globals():
clients["job"].delete_batch_prediction_job(name=batch_job_id)
except Exception as e:
print(e)
# Delete the custom job using the Vertex fully qualified identifier for the custom job
try:
if delete_customjob and "job_id" in globals():
clients["job"].delete_custom_job(name=job_id)
except Exception as e:
print(e)
# Delete the hyperparameter tuning job using the Vertex fully qualified identifier for the hyperparameter tuning job
try:
if delete_hptjob and "hpt_job_id" in globals():
clients["job"].delete_hyperparameter_tuning_job(name=hpt_job_id)
except Exception as e:
print(e)
if delete_bucket and "BUCKET_NAME" in globals():
! gsutil rm -r $BUCKET_NAME
Explanation: Cleaning up
To clean up all GCP resources used in this project, you can delete the GCP
project you used for the tutorial.
Otherwise, you can delete the individual resources you created in this tutorial:
Dataset
Pipeline
Model
Endpoint
Batch Job
Custom Job
Hyperparameter Tuning Job
Cloud Storage Bucket
End of explanation |
3,433 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Your structured data into Tensorflow.
ML training often expects flat data, like a line in a CSV.
tf.Example was
designed to represent flat data. But the data you care about and want to predict
things about usually starts out structured.
Over and over again you have to write transform code that turns your structured data into Tensors. This repetitive transform code must be rewritten over and over for all your ML pipelines both for training and serving! And it lets bugs slip into your ML pipeline.
struct2tensor lets you take advantage of structured data within your ML pipelines. It is
Step5: Some Pretty Printing and Imports
(not the "real" work yet)
Step7: The real work
Step9: Lets see it in action
Step11: See how we went from our pre-pipeline data (the Protobuffer) all the way to the structured data, packed into SparseTensors?
Digging Far Deeper
Interested and want to learn more? Read on...
Let's define several terms we mentioned before
Step13: We will be using visualizations like this to demostrate struct2tensor queries later.
Note
Step14: We will talk about common struct2tensor queries in later sections.
Projection
A projection of paths in a Prensor produces another Prensor with just the selected paths.
Logical representation of a projection
The structure of the projected path can be represented losslessly as nested lists. For example, the projection of event.action.number_of_views from the struct2tensorTree formed by the following two instances of struct2tensor.test.Session
Step15: struct2tensor's internal data model is closer to the above "nested lists" abstraction and sometimes it's easier to reason with "nested lists" than with SparseTensors.
Recently, tf.RaggedTensor was introduced to represent nested lists exactly. We are working on adding support for projecting into ragged tensors.
Common struct2tensor Queries
promote
Promotes a node to become a sibling of its parent. If the node is repeated, then all its values are concatenated (the order is preserved).
Step17: promote(source_path="event.query_token", new_field_name="event_query_token")
Step18: The projected structure is like
Step20: broadcast(source_path="session_id", sibling_field="event", new_field_name="session_session_id")
Step23: The projected structure is like
Step24: reroot
Makes the given node the new root of the struct2tensorTree. This has two effects
Step31: reroot("event")
Step33: Proto Map
You can specify a key for the proto map field in a path via brackets.
Given the following tf.Example
Step34: Apache Parquet Support
struct2tensor offers an Apache Parquet tf.DataSet that allows reading from a Parquet file and apply queries to manipulate the structure of the data.
Because of the powerful struct2tensor library, the dataset will only read the Parquet columns that are required. This reduces I/O cost if we only need a select few columns.
Preparation
Please run the code cell at Some Pretty Printing and Imports to ensure that all required modules are imported, and that pretty print works properly.
Prepare the input data
Step35: Example
We will use a sample Parquet data file (dremel_example.parquet), which contains data based on the example used in this paper | Python Code:
#@test {"skip": true}
# install struct2tensor
!pip install struct2tensor
# graphviz for pretty output
!pip install graphviz
Explanation: Your structured data into Tensorflow.
ML training often expects flat data, like a line in a CSV.
tf.Example was
designed to represent flat data. But the data you care about and want to predict
things about usually starts out structured.
Over and over again you have to write transform code that turns your structured data into Tensors. This repetitive transform code must be rewritten over and over for all your ML pipelines both for training and serving! And it lets bugs slip into your ML pipeline.
struct2tensor lets you take advantage of structured data within your ML pipelines. It is:
for: ML Engineers
who: train models on data that starts out structured
it is: a python library
that: transforms your structured data into model-friendly (Sparse, Raggged, Dense, ...) tensors hermetically within your model
unlike: writing custom transforms over and over for training and serving.
Demo example
Suppose we have this structured data we want to train on. The source example data format is a protobuff. struct2tensor was built internally and works on protobuffers now. It can be extended to parquet, json, etc. in the future.
```
e.g. a web session
message Session{
message SessionInfo {
string session_feature = 1;
double session_duration_sec = 2;
}
SessionInfo session_info = 1;
message Event {
string query = 1;
message Action {
int number_of_views = 1;
}
repeated Action action = 2;
}
repeated Event event = 2;
}
```
In 3 steps we'll extract the fields we want with struct2tensor. We'll end up with batch-aligned SparseTensors:
Tell our model what examples we care about, e.g. event (submessage Session::Event).
Pick the proto fields that we think are good features, say:
session_info.session_feature
event.query
Identify the label to predict, say event.action.number_of_views (the actual label could be sum(action.number_of_views for action in event))
Then we can build a struct2tensor query that:
* parses instances of this protocol buffer
* transforms the fields we care about
* creates the necessary SparseTensors
Don't worry about some of these terms yet. We'll show you an example. And then explain the terms later.
Install required packages (internal colab users: skip)
End of explanation
import base64
import numpy as np
import pprint
import os
import tensorflow
from graphviz import Source
import tensorflow as tf
from IPython.display import Image
from IPython.lib import pretty
import struct2tensor as s2t
from struct2tensor.test import test_pb2
from google.protobuf import text_format
def _display(graph):
Renders a graphviz digraph.
s = Source(graph)
s.format='svg'
return s
def _create_query_from_text_sessions(text_sessions):
Creates a struct2tensor query from a list of pbtxt of struct2tensor.test.Session.
sessions = tf.constant([
text_format.Merge(
text_session,
test_pb2.Session()
).SerializeToString()
for text_session in text_sessions
])
return s2t.create_expression_from_proto(
sessions, test_pb2.Session.DESCRIPTOR)
def _prensor_pretty_printer(prensor, p, cycle):
Pretty printing function for struct2tensor.prensor.Prensor
pretty.pprint(prensor.get_sparse_tensors())
def _sp_pretty_printer(sp, p, cycle):
Pretty printing function for SparseTensor.
del cycle
p.begin_group(4, "SparseTensor(")
p.text("values={}, ".format(sp.values.numpy().tolist()))
p.text("dense_shape={}, ".format(sp.dense_shape.numpy().tolist()))
p.break_()
p.text("indices={}".format(sp.indices.numpy().tolist()))
p.end_group(4, ")")
pretty.for_type(tf.SparseTensor, _sp_pretty_printer)
pretty.for_type(s2t.Prensor, _prensor_pretty_printer)
_pretty_print = pretty.pprint
print("type-specific pretty printing ready to go")
Explanation: Some Pretty Printing and Imports
(not the "real" work yet)
End of explanation
@tf.function(input_signature=[tf.TensorSpec(shape=(None), dtype=tf.string)], autograph=False)
def parse_session(serialized_sessions):
A TF function parsing a batch of serialized Session protos into tensors.
It is a TF graph that takes one 1-D tensor as input, and outputs a
Dict[str, tf.SparseTensor]
query = s2t.create_expression_from_proto(
serialized_sessions, test_pb2.Session.DESCRIPTOR)
# Move all the fields of our interest to under "event".
query = query.promote_and_broadcast({
"session_feature": "session_info.session_feature",
"action_number_of_views": "event.action.number_of_views" },
"event")
# Specify "event" to be examples.
query = query.reroot("event")
# Extract all the fields of our interest.
projection = query.project(["session_feature", "query", "action_number_of_views"])
prensors = s2t.calculate_prensors([projection])
output_sparse_tensors = {}
for prensor in prensors:
path_to_tensor = prensor.get_sparse_tensors()
output_sparse_tensors.update({str(k): v for k, v in path_to_tensor.items()})
return output_sparse_tensors
print("Defined the workhorse func: (structured data at rest) -> (tensors)")
Explanation: The real work:
A function that parses our structured data (protobuffers) into tensors:
End of explanation
serialized_sessions = tf.constant([
text_format.Merge(
session_info {
session_duration_sec: 1.0
session_feature: "foo"
}
event {
query: "Hello"
action {
number_of_views: 1
}
action {
}
}
event {
query: "world"
action {
number_of_views: 2
}
action {
number_of_views: 3
}
}
,
test_pb2.Session()
).SerializeToString()
])
_pretty_print(parse_session(serialized_sessions))
Explanation: Lets see it in action:
End of explanation
#@title { display-mode: "form" }
#@test {"skip": true}
_display(
digraph {
root -> session [label="*"];
session -> event [label="*"];
session -> session_id [label="?"];
event -> action [label="*"];
event -> query_token [label="*"]
action -> number_of_views [label="?"];
}
)
Explanation: See how we went from our pre-pipeline data (the Protobuffer) all the way to the structured data, packed into SparseTensors?
Digging Far Deeper
Interested and want to learn more? Read on...
Let's define several terms we mentioned before:
Prensor
A Prensor (protobuffer + tensor) is a data structure storing the data we work on. We use protobuffers a lot at Google. struct2tensor can support other structured formats, too.
For example, throughout this colab we will be using proto
struct2tensor.test.Session. A schematic visualization
of a selected part of the prensor from that proto looks like:
End of explanation
#@title { display-mode: "form" }
#@test {"skip": true}
_display(
digraph {
session_session_id [color="red"];
root -> session [label="*"];
session -> event [label="*"];
session -> session_id [label="?"];
event -> action [label="*"];
event -> session_session_id [label="?"];
event -> query_token [label="*"];
action -> number_of_views [label="?"];
}
)
Explanation: We will be using visualizations like this to demostrate struct2tensor queries later.
Note:
The "*" on the edge means the pointed node has repeated values; while the "?" means it has an optional value.
There is always a "root" node whose only child is the root of the structure. Note that it's "repeated" because one struct2tensorTree can represent multiple instances of a structure.
struct2tensor Query
A struct2tensor query transforms a Prensor into another Prensor.
For example, broadcast is a query that replicates a node as a child of one of its siblings.
Applying
broadcast(
source_path="session.session_id",
sibling="event",
new_field_name="session_session_id")
on the previous tree gives:
End of explanation
query = _create_query_from_text_sessions(['''
event { action { number_of_views: 1} action { number_of_views: 2} action {} }
event {}
''', '''
event { action { number_of_views: 3} }
''']
).project(["event.action.number_of_views"])
prensor = s2t.calculate_prensors([query])
pretty.pprint(prensor)
Explanation: We will talk about common struct2tensor queries in later sections.
Projection
A projection of paths in a Prensor produces another Prensor with just the selected paths.
Logical representation of a projection
The structure of the projected path can be represented losslessly as nested lists. For example, the projection of event.action.number_of_views from the struct2tensorTree formed by the following two instances of struct2tensor.test.Session:
{
event { action { number_of_views: 1} action { number_of_views: 2} action {} }
event {}
}, {
event { action { number_of_views: 3} }
}
is:
[ # the outer list has two elements b/c there are two Session protos.
[ # the first proto has two events
[[1],[2],[]], # 3 actions, the last one does not have a number_of_views.
[], # the second event does not have action
],
[ # the second proto has one event
[[3]],
],
]
Representing nested lists with tf.SparseTensor
struct2tensor uses tf.SparseTensor to represent the above nested list in the projection results. Note that tf.SparseTensor essentially enforces that the lists nested at the same level to have the same length (because the there is a certain size for each dimension), therefore this representation is lossy. The above nested lists, when written as a SparseTensor will look like:
tf.SparseTensor(
dense_shape=[2, 2, 3, 1], # each is the maximum length of lists at the same nesting level.
values = [1, 2, 3],
indices = [[0, 0, 0, 0], [0, 0, 1, 0], [1, 0, 0, 0]]
)
Note that the last dimension is useless: the index of that dimension will always be 0 for any present value because number_of_views is an optional field. So struct2tensors library will actually "squeeze" all the optional dimensions.
The actual result would be:
End of explanation
#@title { display-mode: "form" }
#@test {"skip": true}
_display('''
digraph {
root -> session [label="*"];
session -> event [label="*"];
event -> query_token [label="*"];
}
''')
Explanation: struct2tensor's internal data model is closer to the above "nested lists" abstraction and sometimes it's easier to reason with "nested lists" than with SparseTensors.
Recently, tf.RaggedTensor was introduced to represent nested lists exactly. We are working on adding support for projecting into ragged tensors.
Common struct2tensor Queries
promote
Promotes a node to become a sibling of its parent. If the node is repeated, then all its values are concatenated (the order is preserved).
End of explanation
#@title { display-mode: "form" }
#@test {"skip": true}
_display('''
digraph {
event_query_token [color="red"];
root -> session [label="*"];
session -> event [label="*"];
session -> event_query_token [label="*"];
event -> query_token [label="*"];
}
''')
query = (_create_query_from_text_sessions([
event {
query_token: "abc"
query_token: "def"
}
event {
query_token: "ghi"
}
])
.promote(source_path="event.query_token", new_field_name="event_query_token")
.project(["event_query_token"]))
prensor = s2t.calculate_prensors([query])
_pretty_print(prensor)
Explanation: promote(source_path="event.query_token", new_field_name="event_query_token")
End of explanation
#@title { display-mode: "form" }
#@test {"skip": true}
_display('''
digraph {
root -> session [label="*"];
session -> session_id [label="?"];
session -> event [label="*"];
}
''')
Explanation: The projected structure is like:
{
# this is under Session.
event_query_token: "abc"
event_query_token: "def"
event_query_token: "ghi"
}
broadcast
Broadcasts the value of a node to one of its sibling. The value will be replicated if the sibling is repeated. This is similar to TensorFlow and Numpy's broadcasting semantics.
End of explanation
#@title { display-mode: "form" }
#@test {"skip": true}
_display('''
digraph {
session_session_id [color="red"];
root -> session [label="*"];
session -> session_id [label="?"];
session -> event [label="*"];
event -> session_session_id [label="?"];
}
''')
query = (_create_query_from_text_sessions([
session_id: 8
event { }
event { }
])
.broadcast(source_path="session_id",
sibling_field="event",
new_field_name="session_session_id")
.project(["event.session_session_id"]))
prensor = s2t.calculate_prensors([query])
_pretty_print(prensor)
Explanation: broadcast(source_path="session_id", sibling_field="event", new_field_name="session_session_id")
End of explanation
query = (_create_query_from_text_sessions([
session_id: 8
,
session_id: 9
])
.map_field_values("session_id", lambda x: tf.add(x, 1), dtype=tf.int64,
new_field_name="session_id_plus_one")
.project(["session_id_plus_one"]))
prensor = s2t.calculate_prensors([query])
_pretty_print(prensor)
Explanation: The projected structure is like:
{
event {
session_session_id: 8
}
event {
session_session_id: 8
}
}
promote_and_broadcast
The query accepts multiple source fields and a destination field. For each source field, it first promotes it to the least common ancestor with the destination field (if necessary), then broadcasts it to the destination field (if necessary).
Usually for the purpose of machine learning, this gives a reasonable flattened representation of nested structures.
promote_and_broadcast(
path_dictionary={
'session_info_duration_sec': 'session_info.session_duration_sec'},
dest_path_parent='event.action')
is equivalent to:
```
promote(source_path='session_info.session_duration_sec',
new_field_name='anonymous_field1')
broadcast(source_path='anonymous_field1',
sibling_field='event.action',
new_field_name='session_info_duration_sec')
```
map_field_values
Creates a new node that is a sibling of a leaf node. The values of the new node are results of applying the given function to the values of the source node.
Note that the function provided takes 1-D tensor that contains all the values of the source node as input and should also output a 1-D tensor of the same size, and it should build TF ops.
End of explanation
#@title { display-mode: "form" }
#@test {"skip": true}
_display('''
digraph {
root -> session [label="*"];
session -> session_id [label="?"];
session -> event [label="*"];
event -> event_id [label="?"];
}
''')
Explanation: reroot
Makes the given node the new root of the struct2tensorTree. This has two effects:
restricts the scope of the struct2tensorTree
The field paths in all the following queries are relative to the new root
There's no way to refer to nodes that are outside the subtree rooted at the new root.
changes the batch dimension.
End of explanation
#@title { display-mode: "form" }
#@test {"skip": true}
_display('''
digraph {
root -> event [label="*"];
event -> event_id [label="?"];
}
''')
#@title { display-mode: "form" }
text_protos = [
session_id: 1
event {
event_id: "a"
}
event {
event_id: "b"
}
,
session_id: 2
,
session_id: 3
event {
event_id: "c"
}
]
print(Assume the following Sessions: )
print([text_format.Merge(p, s2t.test.test_pb2.Session()) for p in text_protos])
print("\n")
reroot_example_query = _create_query_from_text_sessions(text_protos)
print(project(["event.event_id"]) before reroot() (the batch dimension is the index to sessions):)
_pretty_print(s2t.calculate_prensors([reroot_example_query.project(["event.event_id"])]))
print("\n")
print(project(["event_id"]) after reroot() (the batch dimension becomes the index to events):)
_pretty_print(s2t.calculate_prensors([reroot_example_query.reroot("event").project(["event_id"])]))
Explanation: reroot("event")
End of explanation
tf_example = text_format.Parse(
features {
feature {
key: "my_feature"
value {
float_list {
value: 1.0
}
}
}
feature {
key: "other_feature"
value {
bytes_list {
value: "my_val"
}
}
}
}
, tf.train.Example())
query = s2t.create_expression_from_proto(
tf_example.SerializeToString(), tf.train.Example.DESCRIPTOR)
query = query.promote_and_broadcast({'my_new_feature': "features.feature[my_feature].float_list.value", "other_new_feature": "features.feature[other_feature].bytes_list.value"}, "features")
query = query.project(["features.my_new_feature", "features.other_new_feature"])
[prensor] = s2t.calculate_prensors([query])
ragged_tensors = prensor.get_ragged_tensors()
print(ragged_tensors)
Explanation: Proto Map
You can specify a key for the proto map field in a path via brackets.
Given the following tf.Example:
features {
feature {
key: "my_feature"
value {
float_list {
value: 1.0
}
}
}
feature {
key: "other_feature"
value {
bytes_list {
value: "my_val"
}
}
}
}
To get the values of my_feature and other_feature, we can promote_and_broadcast and project the following paths: features.feature[my_feature].float_list.value and features.feature[other_feature].bytes_list.value
This results in the following dict of ragged tensors:
{
features.my_new_feature: <tf.RaggedTensor [[[1.0]]]>,
features.other_new_feature: <tf.RaggedTensor [[[b'my_val']]]>
}
Note: we renamed my_feature to my_new_feature in the promote_and_broadcast (and similarly for other_feature).
End of explanation
# Download our sample data file from the struct2tensor repository. The desciption of the data is below.
#@test {"skip": true}
!curl -o dremel_example.parquet 'https://raw.githubusercontent.com/google/struct2tensor/master/struct2tensor/testdata/parquet_testdata/dremel_example.parquet'
Explanation: Apache Parquet Support
struct2tensor offers an Apache Parquet tf.DataSet that allows reading from a Parquet file and apply queries to manipulate the structure of the data.
Because of the powerful struct2tensor library, the dataset will only read the Parquet columns that are required. This reduces I/O cost if we only need a select few columns.
Preparation
Please run the code cell at Some Pretty Printing and Imports to ensure that all required modules are imported, and that pretty print works properly.
Prepare the input data
End of explanation
#@test {"skip": true}
from struct2tensor import expression_impl
filenames = ["dremel_example.parquet"]
batch_size = 1
exp = s2t.expression_impl.parquet.create_expression_from_parquet_file(filenames)
new_exp = exp.promote_and_broadcast({"new_field": "Links.Forward"}, "Name")
proj_exp = new_exp.project(["Name.new_field"])
proj_exp_needed = exp.project(["Name.Url"])
# Please note that currently, proj_exp_needed needs to be passed into calculate.
# This is due to the way data is stored in parquet (values and repetition &
# definition levels). To construct the node for "Name", we need to read the
# values of a column containing "Name".
pqds = s2t.expression_impl.parquet.calculate_parquet_values([proj_exp, proj_exp_needed], exp,
filenames, batch_size)
for prensors in pqds:
new_field_prensor = prensors[0]
print("============================")
print("Schema of new_field prensor: ")
print(new_field_prensor)
print("\nSparse tensor representation: ")
pretty.pprint(new_field_prensor)
print("============================")
Explanation: Example
We will use a sample Parquet data file (dremel_example.parquet), which contains data based on the example used in this paper: https://storage.googleapis.com/pub-tools-public-publication-data/pdf/36632.pdf
The file dremel_example.parquet has the following schema:
message Document {
required int64 DocId;
optional group Links {
repeated int64 Backward;
repeated int64 Forward; }
repeated group Name {
repeated group Language {
required string Code;
optional string Country; }
optional string Url; }}
and contains the following data:
Document
DocId: 10
Links
Forward: 20
Forward: 40
Forward: 60
Name
Language
Code: 'en-us'
Country: 'us'
Language
Code: 'en'
Url: 'http://A'
Name
Url: 'http://B'
Name
Language
Code: 'en-gb'
Country: 'gb'
Document
DocId: 20
Links
Backward: 10
Backward: 30
Forward: 80
Name
Url: 'http://C'
In this example, we will promote and broadcast the field Links.Forward and project it.
batch_size will be the number of records (Document) per prensor. This works with optional and repeated fields, and will be able to batch the entire record.
Feel free to try batch_size = 2 in the below code. (Note this parquet file only has 2 records (Document) total).
End of explanation |
3,434 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Permutation F-test on sensor data with 1D cluster level
One tests if the evoked response is significantly different
between conditions. Multiple comparison problem is addressed
with cluster level permutation test.
Step1: Set parameters
Step2: Read epochs for the channel of interest
Step3: Compute statistic
Step4: Plot | Python Code:
# Authors: Alexandre Gramfort <[email protected]>
#
# License: BSD (3-clause)
import matplotlib.pyplot as plt
import mne
from mne import io
from mne.stats import permutation_cluster_test
from mne.datasets import sample
print(__doc__)
Explanation: Permutation F-test on sensor data with 1D cluster level
One tests if the evoked response is significantly different
between conditions. Multiple comparison problem is addressed
with cluster level permutation test.
End of explanation
data_path = sample.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif'
tmin = -0.2
tmax = 0.5
# Setup for reading the raw data
raw = io.read_raw_fif(raw_fname)
events = mne.read_events(event_fname)
channel = 'MEG 1332' # include only this channel in analysis
include = [channel]
Explanation: Set parameters
End of explanation
picks = mne.pick_types(raw.info, meg=False, eog=True, include=include,
exclude='bads')
event_id = 1
reject = dict(grad=4000e-13, eog=150e-6)
epochs1 = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject)
condition1 = epochs1.get_data() # as 3D matrix
event_id = 2
epochs2 = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=reject)
condition2 = epochs2.get_data() # as 3D matrix
condition1 = condition1[:, 0, :] # take only one channel to get a 2D array
condition2 = condition2[:, 0, :] # take only one channel to get a 2D array
Explanation: Read epochs for the channel of interest
End of explanation
threshold = 6.0
T_obs, clusters, cluster_p_values, H0 = \
permutation_cluster_test([condition1, condition2], n_permutations=1000,
threshold=threshold, tail=1, n_jobs=1)
Explanation: Compute statistic
End of explanation
times = epochs1.times
plt.close('all')
plt.subplot(211)
plt.title('Channel : ' + channel)
plt.plot(times, condition1.mean(axis=0) - condition2.mean(axis=0),
label="ERF Contrast (Event 1 - Event 2)")
plt.ylabel("MEG (T / m)")
plt.legend()
plt.subplot(212)
for i_c, c in enumerate(clusters):
c = c[0]
if cluster_p_values[i_c] <= 0.05:
h = plt.axvspan(times[c.start], times[c.stop - 1],
color='r', alpha=0.3)
else:
plt.axvspan(times[c.start], times[c.stop - 1], color=(0.3, 0.3, 0.3),
alpha=0.3)
hf = plt.plot(times, T_obs, 'g')
plt.legend((h, ), ('cluster p-value < 0.05', ))
plt.xlabel("time (ms)")
plt.ylabel("f-values")
plt.show()
Explanation: Plot
End of explanation |
3,435 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Logistic Regression Demo
Shown the basic case and treatments for special cases
Step1: Scenario 1) Basic Case
Step2: Scenario 2) Imbalanced Dataset
Step3: => without any correction
Step4: !!! so 98% precision... as the input data..
=> with correction
Step5: Scenario 3) Too many (unrelated) features | Python Code:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn import metrics, cross_validation
from sklearn import datasets
# function to get data samples
def get_dataset(N_datapoints = 100000, class_ratio=0.5):
num_observations_a = int(class_ratio * N_datapoints)
num_observations_b = int((1 - class_ratio) * N_datapoints)
np.random.seed(12)
feature1 = np.random.multivariate_normal([0, 0], [[1, .75],[.75, 1]], num_observations_a)
feature2 = np.random.multivariate_normal([1, 1], [[1, .75],[.75, 1]], num_observations_b)
X = np.vstack((feature1, feature2)).astype(np.float32)
y = np.hstack((np.zeros(num_observations_a), np.ones(num_observations_b)))
y = np.reshape(y, (len(y), 1))
data = np.concatenate((X, y), axis=1)
df = pd.DataFrame(data, columns =['x1', 'x2', 'label'])
return df
def get_dataset(N_datapoints = 100000, class_ratio=0.5, N_features_noise=0):
num_observations_a = int(class_ratio * N_datapoints)
num_observations_b = int((1 - class_ratio) * N_datapoints)
np.random.seed(12)
features = []
feature1 = np.random.multivariate_normal([0, 0], [[1, .75],[.75, 1]], num_observations_a)
feature2 = np.random.multivariate_normal([1, 1], [[1, .75],[.75, 1]], num_observations_b)
# noise features of n datapoints
features_noise = []
num_observations_noise = 0
noise_features = []
for i in range(N_features_noise):
num_observations_noise += N_datapoints
noise_features.append(np.random.choice([0, 1], size=(num_observations_noise), p=[0.5, 0.5]))
features_noise.append(np.random.multivariate_normal([0, 0], [[1, 0.],[0., 1]], N_datapoints))
# collect all the features
features.extend([feature1])
features.extend([feature2])
features.extend(features_noise)
X = np.vstack(features).astype(np.float32)
y = np.hstack((
np.zeros(num_observations_a),
np.ones(num_observations_b),
noise_features
# np.random.choice([0, 1], size=(num_observations_noise), p=[0.5, 0.5])
))
y = np.reshape(y, (len(y), 1))
data = np.concatenate((X, y), axis=1)
col_names = []
col_names.extend(['x1'])
col_names.extend(['x2'])
for i in range(N_features_noise):
col_names.extend(['x_noise_'+str(i)])
col_names.extend(['label'])
print col_names
print data.shape
df = pd.DataFrame(data, columns=col_names)
return df
df = get_dataset(N_datapoints = 100000, class_ratio=0.5, N_features_noise=10)
Explanation: Logistic Regression Demo
Shown the basic case and treatments for special cases:
- imbalanced datasets
- too many parameters (regularization)
End of explanation
# Not imbalanaced datasets (both classes same number of rows)
df = get_dataset(class_ratio=0.5)
fig, ax = plt.subplots()
plt.scatter(df['x1'].values, df['x2'].values, c=df['label'].values, alpha = .2)
display(fig)
predicted = cross_validation.cross_val_predict(LogisticRegression(), df[['x1', 'x2']], df['label'], cv=10)
print metrics.accuracy_score(df['label'], predicted)
Explanation: Scenario 1) Basic Case
End of explanation
# Very imbalanced dataset (e.g. a study of fraud data)
df = get_dataset(class_ratio=0.98)
fig, ax = plt.subplots()
plt.scatter(df['x1'].values,df['x2'].values, c=df['label'].values, alpha = .2)
display(fig)
Explanation: Scenario 2) Imbalanced Dataset
End of explanation
predicted = cross_validation.cross_val_predict(LogisticRegression(), df[['x1', 'x2']], df['label'], cv=10)
print metrics.accuracy_score(df['label'], predicted)
Explanation: => without any correction
End of explanation
# we correct for the imbalanced using the argument class_weight='balanced'
predicted = cross_validation.cross_val_predict(LogisticRegression(class_weight ='balanced'), df[['x1', 'x2']], df['label'], cv=10)
print metrics.accuracy_score(df['label'], predicted)
Explanation: !!! so 98% precision... as the input data..
=> with correction
End of explanation
df = get_dataset(N_datapoints = 100000, class_ratio=0.5, N_features_noise=10)
df_pl =df.sample(frac=0.01)
fig, ax = plt.subplots(1, 3, figsize=(16, 4))
df_pl.plot.scatter('x1', 'x2',c='label', ax=ax[0])
df_pl.plot.scatter('x1', 'x_noise_1',c='label', ax=ax[1])
df_pl.plot.scatter('x_noise_1', 'x_noise_2',c='label', ax=ax[2])
# ax[0].scatter(df_pl['x1'].values,df['x2'].values, c=df_pl['label'].values, alpha = .2)
# ax[1].scatter(df_pl['x1'].values,df['x3'].values, c=df_pl['label'].values, alpha = .2)
# ax[2].scatter(df_pl['x1'].values,df['x3'].values, c=df_pl['label'].values, alpha = .2)
display(fig)
Explanation: Scenario 3) Too many (unrelated) features
End of explanation |
3,436 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
MPI через ipyparallel
Step1: Используем MPI
Step2: MPI на Google Colab
Step3: Далее действуем как указанно выше для запуска MPI через Jupyter.
CUDA через Numba
Если вы запускаете ноутбук через Google Colab, то для доступа к GPU вам нужно изменить настройки по-умолчанию | Python Code:
# Jupyter поддерживает работу с кластером через пакет ipyparallel
# https://ipyparallel.readthedocs.io/en/latest/
# Его можно установить через PIP
# ! pip3 install ipyparallel
# После установки в интерфейсе Jupyter должна появиться вкладка IPython Clusters.
# Если этого не произошло, то нужно сделать:
# ipcluster nbextension enable
# ipyparallel кластер можно запусить из Jupyter из вкладки IPython Clusters.
# Альтернативно можно создать кластер из консоли:
# ! ipcluster start --profile=mpi -n 16
# По умолчанию процессы для счета создаются на локальной машине.
# Здесь мы попросили создать 16 процессов и указали, что будем использовать MPI (см. ниже).
# Для работы с MPI потребуется какая-либо реализация интерфейса
# ! sudo apt install openmpi-bin
# и вспомогательная библиотека
# ! pip3 install mpi4py
# Чтобы получить доступ к узлам кластера, нам потребуется импортировать библиотеку
import ipyparallel as ipp
# Теперь мы можем создать интерфейс для работы с этими процессами.
rc = ipp.Client(profile='mpi')
# Смотрим, какие процессы были созданы:
print(f"{rc.ids}")
# Создадим "вид", для просмотра данных процессов
view = rc[:]
print(view)
# Следующая строка нужна для использования магии Jupyter
view.activate()
# Теперь мы можем выполнить содержимое ячейки на всех с помощью заклинания %%px.
Explanation: MPI через ipyparallel
End of explanation
%%px
from mpi4py import MPI
import numpy as np
def psum(a):
locsum = np.sum(a)
rcvBuf = np.array(0.0,'d')
MPI.COMM_WORLD.Allreduce([locsum, MPI.DOUBLE],
[rcvBuf, MPI.DOUBLE],
op=MPI.SUM)
return rcvBuf
%pxresult
# Запускаем содержимое файла (идентично предыдущей ячейки) на каждой узле.
# view.run('psum.py')
# Импорт numpy нужен, так как ячейкой выше мы сделали это на удаленных машинах.
import numpy as np
# Рассылаем массив на все узлы кластера равными порциями.
view.scatter('a',np.arange(63,dtype='float'))
# Выводим содержимое массива `a` на каждой узле.
view['a']
# Вызываем написанную нами функцию суммирования:
%px totalsum = psum(a)
# Смотрим результат
%pxresult
# Аналогично заклинанию выше.
# view.execute('totalsum = psum(a)')
# Выводим результат, получившийся на каждой машине:
view['totalsum']
Explanation: Используем MPI
End of explanation
! pip install mpi4py
! pip3 install ipyparallel
! ipcluster start --profile=mpi -n 2 --daemonize
Explanation: MPI на Google Colab
End of explanation
# Для работы с NVidia GPU проще всего использовать numba.cuda.
# Устанавливается она как обычная numba
! pip3 install numba
# но для доступа к CUDA должно быть установлено соответствующее окружение, например для Ubuntu
# ! sudo apt install nvidia-cuda-toolkit
# Проверить корректность установки можно командой
! numba -s | grep CUDA
# Документация доступна здесь:
# https://numba.pydata.org/numba-doc/latest/cuda/index.html
# Развернутые сведения об устройстве можно получить командой
# ! clinfo
# Импортируем необходимую библиотеку.
import numba.cuda as cuda
# Проверяем доступность numba.cuda.
print(f"{cuda.is_available()}")
# Перечисляем доступные устройства.
cuda.detect()
# Названия функций для математический операций нужно импортировать.
import math
import numpy as np
# Пишем простую функцию для работы на GPU.
@cuda.jit
def cudasqrt(x, y):
i = cuda.grid(1) # Оси в CUDA нумеруются с 1-ой.
if i>=cuda.gridsize(1): return
y[i] = math.sqrt(x[i])
# Считаем корни
x = np.arange(10, dtype=np.float32)**2
y = np.empty_like(x)
cudasqrt[1, 100](x, y) # Обязательно указываем [число блоков, число потоков на блок].
print(y)
Explanation: Далее действуем как указанно выше для запуска MPI через Jupyter.
CUDA через Numba
Если вы запускаете ноутбук через Google Colab, то для доступа к GPU вам нужно изменить настройки по-умолчанию: Меню > Среда выполнения > Сменить среду выполнения > Аппаратный ускоритель > GPU.
End of explanation |
3,437 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Step1: Fully-Connected Neural Nets
In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures.
In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a forward and a backward function. The forward function will receive inputs, weights, and other parameters and will return both an output and a cache object storing data needed for the backward pass, like this
Step4: Affine layer
Step5: Affine layer
Step6: ReLU layer
Step7: ReLU layer
Step8: "Sandwich" layers
There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file cs231n/layer_utils.py.
For now take a look at the affine_relu_forward and affine_relu_backward functions, and run the following to numerically gradient check the backward pass
Step9: Loss layers
Step10: Two-layer network
In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.
Open the file cs231n/classifiers/fc_net.py and complete the implementation of the TwoLayerNet class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation.
Step11: Solver
In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.
Open the file cs231n/solver.py and read through it to familiarize yourself with the API. After doing so, use a Solver instance to train a TwoLayerNet that achieves at least 50% accuracy on the validation set.
Step12: Multilayer network
Next you will implement a fully-connected network with an arbitrary number of hidden layers.
Read through the FullyConnectedNet class in the file cs231n/classifiers/fc_net.py.
Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch normalization; we will add those features soon.
Initial loss and gradient check
As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?
For gradient checking, you should expect to see errors around 1e-6 or less.
Step13: As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. You will need to tweak the learning rate and initialization scale, but you should be able to overfit and achieve 100% training accuracy within 20 epochs.
Step14: Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again you will have to adjust the learning rate and weight initialization, but you should be able to achieve 100% training accuracy within 20 epochs.
Step15: Inline question
Step16: Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster.
Step17: RMSProp and Adam
RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.
In the file cs231n/optim.py, implement the RMSProp update rule in the rmsprop function and implement the Adam update rule in the adam function, and check your implementations using the tests below.
[1] Tijmen Tieleman and Geoffrey Hinton. "Lecture 6.5-rmsprop
Step18: Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules
Step19: Train a good model!
Train the best fully-connected model that you can on CIFAR-10, storing your best model in the best_model variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.
If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.
You might find it useful to complete the BatchNormalization.ipynb and Dropout.ipynb notebooks before completing this part, since those techniques can help you train powerful models.
Step20: Test you model
Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set. | Python Code:
# As usual, a bit of setup
import time
import numpy as np
import matplotlib.pyplot as plt
from cs231n.classifiers.fc_net import *
from cs231n.data_utils import get_CIFAR10_data
from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array
from cs231n.solver import Solver
%matplotlib inline
plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# for auto-reloading external modules
# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython
%load_ext autoreload
%autoreload 2
def rel_error(x, y):
returns relative error
return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))
# Load the (preprocessed) CIFAR10 data.
data = get_CIFAR10_data()
for k, v in data.iteritems():
print '%s: ' % k, v.shape
Explanation: Fully-Connected Neural Nets
In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures.
In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a forward and a backward function. The forward function will receive inputs, weights, and other parameters and will return both an output and a cache object storing data needed for the backward pass, like this:
```python
def layer_forward(x, w):
Receive inputs x and weights w
# Do some computations ...
z = # ... some intermediate value
# Do some more computations ...
out = # the output
cache = (x, w, z, out) # Values we need to compute gradients
return out, cache
```
The backward pass will receive upstream derivatives and the cache object, and will return gradients with respect to the inputs and weights, like this:
```python
def layer_backward(dout, cache):
Receive derivative of loss with respect to outputs and cache,
and compute derivative with respect to inputs.
# Unpack cache values
x, w, z, out = cache
# Use values in cache to compute derivatives
dx = # Derivative of loss with respect to x
dw = # Derivative of loss with respect to w
return dx, dw
```
After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.
In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch Normalization as a tool to more efficiently optimize deep networks.
End of explanation
# Test the affine_forward function
num_inputs = 2
input_shape = (4, 5, 6)
output_dim = 3
input_size = num_inputs * np.prod(input_shape)
weight_size = output_dim * np.prod(input_shape)
x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)
w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)
b = np.linspace(-0.3, 0.1, num=output_dim)
out, _ = affine_forward(x, w, b)
correct_out = np.array([[ 1.49834967, 1.70660132, 1.91485297],
[ 3.25553199, 3.5141327, 3.77273342]])
# Compare your output with ours. The error should be around 1e-9.
print 'Testing affine_forward function:'
print 'difference: ', rel_error(out, correct_out)
Explanation: Affine layer: foward
Open the file cs231n/layers.py and implement the affine_forward function.
Once you are done you can test your implementaion by running the following:
End of explanation
# Test the affine_backward function
x = np.random.randn(10, 2, 3)
w = np.random.randn(6, 5)
b = np.random.randn(5)
dout = np.random.randn(10, 5)
dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)
dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)
db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)
_, cache = affine_forward(x, w, b)
dx, dw, db = affine_backward(dout, cache)
# The error should be around 1e-10
print 'Testing affine_backward function:'
print 'dx error: ', rel_error(dx_num, dx)
print 'dw error: ', rel_error(dw_num, dw)
print 'db error: ', rel_error(db_num, db)
Explanation: Affine layer: backward
Now implement the affine_backward function and test your implementation using numeric gradient checking.
End of explanation
# Test the relu_forward function
x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)
out, _ = relu_forward(x)
correct_out = np.array([[ 0., 0., 0., 0., ],
[ 0., 0., 0.04545455, 0.13636364,],
[ 0.22727273, 0.31818182, 0.40909091, 0.5, ]])
# Compare your output with ours. The error should be around 1e-8
print 'Testing relu_forward function:'
print 'difference: ', rel_error(out, correct_out)
Explanation: ReLU layer: forward
Implement the forward pass for the ReLU activation function in the relu_forward function and test your implementation using the following:
End of explanation
x = np.random.randn(10, 10)
dout = np.random.randn(*x.shape)
dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)
_, cache = relu_forward(x)
dx = relu_backward(dout, cache)
# The error should be around 1e-12
print 'Testing relu_backward function:'
print 'dx error: ', rel_error(dx_num, dx)
Explanation: ReLU layer: backward
Now implement the backward pass for the ReLU activation function in the relu_backward function and test your implementation using numeric gradient checking:
End of explanation
from cs231n.layer_utils import affine_relu_forward, affine_relu_backward
x = np.random.randn(2, 3, 4)
w = np.random.randn(12, 10)
b = np.random.randn(10)
dout = np.random.randn(2, 10)
out, cache = affine_relu_forward(x, w, b)
dx, dw, db = affine_relu_backward(dout, cache)
dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)
dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)
db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)
print 'Testing affine_relu_forward:'
print 'dx error: ', rel_error(dx_num, dx)
print 'dw error: ', rel_error(dw_num, dw)
print 'db error: ', rel_error(db_num, db)
Explanation: "Sandwich" layers
There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file cs231n/layer_utils.py.
For now take a look at the affine_relu_forward and affine_relu_backward functions, and run the following to numerically gradient check the backward pass:
End of explanation
num_classes, num_inputs = 10, 50
x = 0.001 * np.random.randn(num_inputs, num_classes)
y = np.random.randint(num_classes, size=num_inputs)
dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)
loss, dx = svm_loss(x, y)
# Test svm_loss function. Loss should be around 9 and dx error should be 1e-9
print 'Testing svm_loss:'
print 'loss: ', loss
print 'dx error: ', rel_error(dx_num, dx)
dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)
loss, dx = softmax_loss(x, y)
# Test softmax_loss function. Loss should be 2.3 and dx error should be 1e-8
print '\nTesting softmax_loss:'
print 'loss: ', loss
print 'dx error: ', rel_error(dx_num, dx)
Explanation: Loss layers: Softmax and SVM
You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in cs231n/layers.py.
You can make sure that the implementations are correct by running the following:
End of explanation
N, D, H, C = 3, 5, 50, 7
X = np.random.randn(N, D)
y = np.random.randint(C, size=N)
std = 1e-2
model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)
print 'Testing initialization ... '
W1_std = abs(model.params['W1'].std() - std)
b1 = model.params['b1']
W2_std = abs(model.params['W2'].std() - std)
b2 = model.params['b2']
assert W1_std < std / 10, 'First layer weights do not seem right'
assert np.all(b1 == 0), 'First layer biases do not seem right'
assert W2_std < std / 10, 'Second layer weights do not seem right'
assert np.all(b2 == 0), 'Second layer biases do not seem right'
print 'Testing test-time forward pass ... '
model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)
model.params['b1'] = np.linspace(-0.1, 0.9, num=H)
model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)
model.params['b2'] = np.linspace(-0.9, 0.1, num=C)
X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T
scores = model.loss(X)
correct_scores = np.asarray(
[[11.53165108, 12.2917344, 13.05181771, 13.81190102, 14.57198434, 15.33206765, 16.09215096],
[12.05769098, 12.74614105, 13.43459113, 14.1230412, 14.81149128, 15.49994135, 16.18839143],
[12.58373087, 13.20054771, 13.81736455, 14.43418138, 15.05099822, 15.66781506, 16.2846319 ]])
scores_diff = np.abs(scores - correct_scores).sum()
assert scores_diff < 1e-6, 'Problem with test-time forward pass'
print 'Testing training loss (no regularization)'
y = np.asarray([0, 5, 1])
loss, grads = model.loss(X, y)
correct_loss = 3.4702243556
assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'
model.reg = 1.0
loss, grads = model.loss(X, y)
correct_loss = 26.5948426952
assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'
for reg in [0.0, 0.7]:
print 'Running numeric gradient check with reg = ', reg
model.reg = reg
loss, grads = model.loss(X, y)
for name in sorted(grads):
f = lambda _: model.loss(X, y)[0]
grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)
print '%s relative error: %.2e' % (name, rel_error(grad_num, grads[name]))
Explanation: Two-layer network
In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.
Open the file cs231n/classifiers/fc_net.py and complete the implementation of the TwoLayerNet class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation.
End of explanation
model = TwoLayerNet(hidden_dim=120, reg=1e-1)
##############################################################################
# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least #
# 50% accuracy on the validation set. #
##############################################################################
solver = Solver(
model, data,
update_rule='sgd',
optim_config={
'learning_rate': 7e-4,
},
lr_decay=0.95,
num_epochs=10,
batch_size=100,
print_every=49000
)
solver.train()
##############################################################################
# END OF YOUR CODE #
##############################################################################
# Run this cell to visualize training loss and train / val accuracy
plt.subplot(2, 1, 1)
plt.title('Training loss')
plt.plot(solver.loss_history, 'o')
plt.xlabel('Iteration')
plt.subplot(2, 1, 2)
plt.title('Accuracy')
plt.plot(solver.train_acc_history, '-o', label='train')
plt.plot(solver.val_acc_history, '-o', label='val')
plt.plot([0.5] * len(solver.val_acc_history), 'k--')
plt.xlabel('Epoch')
plt.legend(loc='lower right')
plt.gcf().set_size_inches(15, 12)
plt.show()
Explanation: Solver
In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.
Open the file cs231n/solver.py and read through it to familiarize yourself with the API. After doing so, use a Solver instance to train a TwoLayerNet that achieves at least 50% accuracy on the validation set.
End of explanation
N, D, H1, H2, C = 2, 15, 20, 30, 10
X = np.random.randn(N, D)
y = np.random.randint(C, size=(N,))
for reg in [0, 3.14]:
print 'Running check with reg = ', reg
model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,
reg=reg, weight_scale=5e-2, dtype=np.float64)
loss, grads = model.loss(X, y)
print 'Initial loss: ', loss
for name in sorted(grads):
f = lambda _: model.loss(X, y)[0]
grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)
print '%s relative error: %.2e' % (name, rel_error(grad_num, grads[name]))
Explanation: Multilayer network
Next you will implement a fully-connected network with an arbitrary number of hidden layers.
Read through the FullyConnectedNet class in the file cs231n/classifiers/fc_net.py.
Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch normalization; we will add those features soon.
Initial loss and gradient check
As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?
For gradient checking, you should expect to see errors around 1e-6 or less.
End of explanation
# TODO: Use a three-layer Net to overfit 50 training examples.
num_train = 50
small_data = {
'X_train': data['X_train'][:num_train],
'y_train': data['y_train'][:num_train],
'X_val': data['X_val'],
'y_val': data['y_val'],
}
weight_scale = 1e-2
learning_rate = 8e-3
model = FullyConnectedNet([100, 100],
weight_scale=weight_scale, dtype=np.float64)
solver = Solver(model, small_data,
print_every=10, num_epochs=20, batch_size=25,
update_rule='sgd',
optim_config={
'learning_rate': learning_rate,
}
)
solver.train()
plt.plot(solver.loss_history, 'o')
plt.title('Training loss history')
plt.xlabel('Iteration')
plt.ylabel('Training loss')
plt.show()
Explanation: As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. You will need to tweak the learning rate and initialization scale, but you should be able to overfit and achieve 100% training accuracy within 20 epochs.
End of explanation
# TODO: Use a five-layer Net to overfit 50 training examples.
num_train = 50
small_data = {
'X_train': data['X_train'][:num_train],
'y_train': data['y_train'][:num_train],
'X_val': data['X_val'],
'y_val': data['y_val'],
}
learning_rate = 1e-2
weight_scale = 5e-2
model = FullyConnectedNet([100, 100, 100, 100],
weight_scale=weight_scale, dtype=np.float64)
solver = Solver(model, small_data,
print_every=10, num_epochs=20, batch_size=25,
update_rule='sgd',
optim_config={
'learning_rate': learning_rate,
}
)
solver.train()
plt.plot(solver.loss_history, 'o')
plt.title('Training loss history')
plt.xlabel('Iteration')
plt.ylabel('Training loss')
plt.show()
Explanation: Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again you will have to adjust the learning rate and weight initialization, but you should be able to achieve 100% training accuracy within 20 epochs.
End of explanation
from cs231n.optim import sgd_momentum
N, D = 4, 5
w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)
dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)
v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)
config = {'learning_rate': 1e-3, 'velocity': v}
next_w, _ = sgd_momentum(w, dw, config=config)
expected_next_w = np.asarray([
[ 0.1406, 0.20738947, 0.27417895, 0.34096842, 0.40775789],
[ 0.47454737, 0.54133684, 0.60812632, 0.67491579, 0.74170526],
[ 0.80849474, 0.87528421, 0.94207368, 1.00886316, 1.07565263],
[ 1.14244211, 1.20923158, 1.27602105, 1.34281053, 1.4096 ]])
expected_velocity = np.asarray([
[ 0.5406, 0.55475789, 0.56891579, 0.58307368, 0.59723158],
[ 0.61138947, 0.62554737, 0.63970526, 0.65386316, 0.66802105],
[ 0.68217895, 0.69633684, 0.71049474, 0.72465263, 0.73881053],
[ 0.75296842, 0.76712632, 0.78128421, 0.79544211, 0.8096 ]])
print 'next_w error: ', rel_error(next_w, expected_next_w)
print 'velocity error: ', rel_error(expected_velocity, config['velocity'])
Explanation: Inline question:
Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net?
Answer:
While keeping the same learning rate, network with more layers requires larger weight scale.
Update rules
So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD.
SGD+Momentum
Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochstic gradient descent.
Open the file cs231n/optim.py and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function sgd_momentum and run the following to check your implementation. You should see errors less than 1e-8.
End of explanation
num_train = 4000
small_data = {
'X_train': data['X_train'][:num_train],
'y_train': data['y_train'][:num_train],
'X_val': data['X_val'],
'y_val': data['y_val'],
}
solvers = {}
for update_rule in ['sgd', 'sgd_momentum']:
print 'running with ', update_rule
model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)
solver = Solver(model, small_data,
num_epochs=5, batch_size=100,
update_rule=update_rule,
optim_config={
'learning_rate': 1e-2,
},
verbose=True)
solvers[update_rule] = solver
solver.train()
print
plt.subplot(3, 1, 1)
plt.title('Training loss')
plt.xlabel('Iteration')
plt.subplot(3, 1, 2)
plt.title('Training accuracy')
plt.xlabel('Epoch')
plt.subplot(3, 1, 3)
plt.title('Validation accuracy')
plt.xlabel('Epoch')
for update_rule, solver in solvers.iteritems():
plt.subplot(3, 1, 1)
plt.plot(solver.loss_history, 'o', label=update_rule)
plt.subplot(3, 1, 2)
plt.plot(solver.train_acc_history, '-o', label=update_rule)
plt.subplot(3, 1, 3)
plt.plot(solver.val_acc_history, '-o', label=update_rule)
for i in [1, 2, 3]:
plt.subplot(3, 1, i)
plt.legend(loc='upper center', ncol=4)
plt.gcf().set_size_inches(15, 15)
plt.show()
Explanation: Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster.
End of explanation
# Test RMSProp implementation; you should see errors less than 1e-7
from cs231n.optim import rmsprop
N, D = 4, 5
w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)
dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)
cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)
config = {'learning_rate': 1e-2, 'cache': cache}
next_w, _ = rmsprop(w, dw, config=config)
expected_next_w = np.asarray([
[-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],
[-0.132737, -0.08078555, -0.02881884, 0.02316247, 0.07515774],
[ 0.12716641, 0.17918792, 0.23122175, 0.28326742, 0.33532447],
[ 0.38739248, 0.43947102, 0.49155973, 0.54365823, 0.59576619]])
expected_cache = np.asarray([
[ 0.5976, 0.6126277, 0.6277108, 0.64284931, 0.65804321],
[ 0.67329252, 0.68859723, 0.70395734, 0.71937285, 0.73484377],
[ 0.75037008, 0.7659518, 0.78158892, 0.79728144, 0.81302936],
[ 0.82883269, 0.84469141, 0.86060554, 0.87657507, 0.8926 ]])
print 'next_w error: ', rel_error(expected_next_w, next_w)
print 'cache error: ', rel_error(expected_cache, config['cache'])
# Test Adam implementation; you should see errors around 1e-7 or less
from cs231n.optim import adam
N, D = 4, 5
w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)
dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)
m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)
v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)
config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}
next_w, _ = adam(w, dw, config=config)
expected_next_w = np.asarray([
[-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],
[-0.1380274, -0.08544591, -0.03286534, 0.01971428, 0.0722929],
[ 0.1248705, 0.17744702, 0.23002243, 0.28259667, 0.33516969],
[ 0.38774145, 0.44031188, 0.49288093, 0.54544852, 0.59801459]])
expected_v = np.asarray([
[ 0.69966, 0.68908382, 0.67851319, 0.66794809, 0.65738853,],
[ 0.64683452, 0.63628604, 0.6257431, 0.61520571, 0.60467385,],
[ 0.59414753, 0.58362676, 0.57311152, 0.56260183, 0.55209767,],
[ 0.54159906, 0.53110598, 0.52061845, 0.51013645, 0.49966, ]])
expected_m = np.asarray([
[ 0.48, 0.49947368, 0.51894737, 0.53842105, 0.55789474],
[ 0.57736842, 0.59684211, 0.61631579, 0.63578947, 0.65526316],
[ 0.67473684, 0.69421053, 0.71368421, 0.73315789, 0.75263158],
[ 0.77210526, 0.79157895, 0.81105263, 0.83052632, 0.85 ]])
print 'next_w error: ', rel_error(expected_next_w, next_w)
print 'v error: ', rel_error(expected_v, config['v'])
print 'm error: ', rel_error(expected_m, config['m'])
Explanation: RMSProp and Adam
RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.
In the file cs231n/optim.py, implement the RMSProp update rule in the rmsprop function and implement the Adam update rule in the adam function, and check your implementations using the tests below.
[1] Tijmen Tieleman and Geoffrey Hinton. "Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude." COURSERA: Neural Networks for Machine Learning 4 (2012).
[2] Diederik Kingma and Jimmy Ba, "Adam: A Method for Stochastic Optimization", ICLR 2015.
End of explanation
learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}
for update_rule in ['adam', 'rmsprop']:
print 'running with ', update_rule
model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)
solver = Solver(model, small_data,
num_epochs=5, batch_size=100,
update_rule=update_rule,
optim_config={
'learning_rate': learning_rates[update_rule]
},
verbose=True)
solvers[update_rule] = solver
solver.train()
print
plt.subplot(3, 1, 1)
plt.title('Training loss')
plt.xlabel('Iteration')
plt.subplot(3, 1, 2)
plt.title('Training accuracy')
plt.xlabel('Epoch')
plt.subplot(3, 1, 3)
plt.title('Validation accuracy')
plt.xlabel('Epoch')
for update_rule, solver in solvers.iteritems():
plt.subplot(3, 1, 1)
plt.plot(solver.loss_history, 'o', label=update_rule)
plt.subplot(3, 1, 2)
plt.plot(solver.train_acc_history, '-o', label=update_rule)
plt.subplot(3, 1, 3)
plt.plot(solver.val_acc_history, '-o', label=update_rule)
for i in [1, 2, 3]:
plt.subplot(3, 1, i)
plt.legend(loc='upper center', ncol=4)
plt.gcf().set_size_inches(15, 15)
plt.show()
Explanation: Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:
End of explanation
best_model = None
################################################################################
# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might #
# batch normalization and dropout useful. Store your best model in the #
# best_model variable. #
################################################################################
pass
################################################################################
# END OF YOUR CODE #
################################################################################
Explanation: Train a good model!
Train the best fully-connected model that you can on CIFAR-10, storing your best model in the best_model variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.
If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.
You might find it useful to complete the BatchNormalization.ipynb and Dropout.ipynb notebooks before completing this part, since those techniques can help you train powerful models.
End of explanation
y_test_pred = np.argmax(best_model.loss(X_test), axis=1)
y_val_pred = np.argmax(best_model.loss(X_val), axis=1)
print 'Validation set accuracy: ', (y_val_pred == y_val).mean()
print 'Test set accuracy: ', (y_test_pred == y_test).mean()
Explanation: Test you model
Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set.
End of explanation |
3,438 | Given the following text problem statement, write Python code to implement the functionality described below in problem statement
Problem:
I have an array of random floats and I need to compare it to another one that has the same values in a different order. For that matter I use the sum, product (and other combinations depending on the dimension of the table hence the number of equations needed). | Problem:
import numpy as np
n = 20
m = 10
tag = np.random.rand(n, m)
s1 = np.sum(tag, axis=1)
s2 = np.sum(tag[:, ::-1], axis=1)
s1 = np.append(s1, np.nan)
s2 = np.append(s2, np.nan)
result = (~np.isclose(s1,s2, equal_nan=True)).sum() |
3,439 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Deep Inverse Regression with Yelp reviews
In this note we'll use gensim to turn the Word2Vec machinery into a document classifier, as in Document Classification by Inversion of Distributed Language Representations from ACL 2015.
Data and prep
First, download to the same directory as this note the data from the Yelp recruiting contest on kaggle
Step1: And put everything together in a review generator that provides tokenized sentences and the number of stars for every review.
Step2: For example
Step3: Now, since the files are small we'll just read everything into in-memory lists. It takes a minute ...
Step4: Finally, write a function to generate sentences -- ordered lists of words -- from reviews that have certain star ratings
Step5: Word2Vec modeling
We fit out-of-the-box Word2Vec
Step6: Build vocab from all sentences (you could also pre-train the base model from a neutral or un-labeled vocabulary)
Step7: Now, we will deep copy each base model and do star-specific training. This is where the big computations happen...
Step9: Inversion of the distributed representations
At this point, we have 5 different word2vec language representations. Each 'model' has been trained conditional (i.e., limited to) text from a specific star rating. We will apply Bayes rule to go from p(text|stars) to p(stars|text).
For any new sentence we can obtain its likelihood (lhd; actually, the composite likelihood approximation; see the paper) using the score function in the word2vec class. We get the likelihood for each sentence in the first test review, then convert to a probability over star ratings. Every sentence in the review is evaluated separately and the final star rating of the review is an average vote of all the sentences. This is all in the following handy wrapper.
Step10: Test set example
As an example, we apply the inversion on the full test set. | Python Code:
import re
contractions = re.compile(r"'|-|\"")
# all non alphanumeric
symbols = re.compile(r'(\W+)', re.U)
# single character removal
singles = re.compile(r'(\s\S\s)', re.I|re.U)
# separators (any whitespace)
seps = re.compile(r'\s+')
# cleaner (order matters)
def clean(text):
text = text.lower()
text = contractions.sub('', text)
text = symbols.sub(r' \1 ', text)
text = singles.sub(' ', text)
text = seps.sub(' ', text)
return text
# sentence splitter
alteos = re.compile(r'([!\?])')
def sentences(l):
l = alteos.sub(r' \1 .', l).rstrip("(\.)*\n")
return l.split(".")
Explanation: Deep Inverse Regression with Yelp reviews
In this note we'll use gensim to turn the Word2Vec machinery into a document classifier, as in Document Classification by Inversion of Distributed Language Representations from ACL 2015.
Data and prep
First, download to the same directory as this note the data from the Yelp recruiting contest on kaggle:
* https://www.kaggle.com/c/yelp-recruiting/download/yelp_training_set.zip
* https://www.kaggle.com/c/yelp-recruiting/download/yelp_test_set.zip
You'll need to sign-up for kaggle.
You can then unpack the data and grab the information we need.
We'll use an incredibly simple parser
End of explanation
from zipfile import ZipFile
import json
def YelpReviews(label):
with ZipFile("yelp_%s_set.zip"%label, 'r') as zf:
with zf.open("yelp_%s_set/yelp_%s_set_review.json"%(label,label)) as f:
for line in f:
rev = json.loads(line)
yield {'y':rev['stars'],\
'x':[clean(s).split() for s in sentences(rev['text'])]}
Explanation: And put everything together in a review generator that provides tokenized sentences and the number of stars for every review.
End of explanation
YelpReviews("test").next()
Explanation: For example:
End of explanation
revtrain = list(YelpReviews("training"))
print len(revtrain), "training reviews"
## and shuffle just in case they are ordered
import numpy as np
np.random.shuffle(revtrain)
Explanation: Now, since the files are small we'll just read everything into in-memory lists. It takes a minute ...
End of explanation
def StarSentences(reviews, stars=[1,2,3,4,5]):
for r in reviews:
if r['y'] in stars:
for s in r['x']:
yield s
Explanation: Finally, write a function to generate sentences -- ordered lists of words -- from reviews that have certain star ratings
End of explanation
from gensim.models import Word2Vec
import multiprocessing
## create a w2v learner
basemodel = Word2Vec(
workers=multiprocessing.cpu_count(), # use your cores
iter=3) # sweeps of SGD through the data; more is better
print basemodel
Explanation: Word2Vec modeling
We fit out-of-the-box Word2Vec
End of explanation
basemodel.build_vocab(StarSentences(revtrain))
Explanation: Build vocab from all sentences (you could also pre-train the base model from a neutral or un-labeled vocabulary)
End of explanation
from copy import deepcopy
starmodels = [deepcopy(basemodel) for i in range(5)]
for i in range(5):
slist = list(StarSentences(revtrain, [i+1]))
print i+1, "stars (", len(slist), ")"
starmodels[i].train( slist, total_examples=len(slist) )
Explanation: Now, we will deep copy each base model and do star-specific training. This is where the big computations happen...
End of explanation
docprob takes two lists
* docs: a list of documents, each of which is a list of sentences
* models: the candidate word2vec models (each potential class)
it returns the array of class probabilities. Everything is done in-memory.
import pandas as pd # for quick summing within doc
def docprob(docs, mods):
# score() takes a list [s] of sentences here; could also be a sentence generator
sentlist = [s for d in docs for s in d]
# the log likelihood of each sentence in this review under each w2v representation
llhd = np.array( [ m.score(sentlist, len(sentlist)) for m in mods ] )
# now exponentiate to get likelihoods,
lhd = np.exp(llhd - llhd.max(axis=0)) # subtract row max to avoid numeric overload
# normalize across models (stars) to get sentence-star probabilities
prob = pd.DataFrame( (lhd/lhd.sum(axis=0)).transpose() )
# and finally average the sentence probabilities to get the review probability
prob["doc"] = [i for i,d in enumerate(docs) for s in d]
prob = prob.groupby("doc").mean()
return prob
Explanation: Inversion of the distributed representations
At this point, we have 5 different word2vec language representations. Each 'model' has been trained conditional (i.e., limited to) text from a specific star rating. We will apply Bayes rule to go from p(text|stars) to p(stars|text).
For any new sentence we can obtain its likelihood (lhd; actually, the composite likelihood approximation; see the paper) using the score function in the word2vec class. We get the likelihood for each sentence in the first test review, then convert to a probability over star ratings. Every sentence in the review is evaluated separately and the final star rating of the review is an average vote of all the sentences. This is all in the following handy wrapper.
End of explanation
# read in the test set
revtest = list(YelpReviews("test"))
# get the probs (note we give docprob a list of lists of words, plus the models)
probs = docprob( [r['x'] for r in revtest], starmodels )
%matplotlib inline
probpos = pd.DataFrame({"out-of-sample prob positive":probs[[3,4]].sum(axis=1),
"true stars":[r['y'] for r in revtest]})
probpos.boxplot("out-of-sample prob positive",by="true stars", figsize=(12,5))
Explanation: Test set example
As an example, we apply the inversion on the full test set.
End of explanation |
3,440 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
MNIST Data Set - Basic Approach
Get the MNIST Data
Step1: Alternative sources of the data just in case
Step2: Visualizing the Data
Step3: Create the Model
Step4: Loss and Optimizer
Step5: Create Session | Python Code:
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./data/MNIST_data/",
one_hot = True)
Explanation: MNIST Data Set - Basic Approach
Get the MNIST Data
End of explanation
type(mnist)
mnist.train.images
mnist.train.num_examples
mnist.test.num_examples
mnist.validation.num_examples
Explanation: Alternative sources of the data just in case:
http://yann.lecun.com/exdb/mnist/
https://github.com/mrgloom/MNIST-dataset-in-different-formats
End of explanation
import matplotlib.pyplot as plt
%matplotlib inline
# The image is a long array
mnist.train.images[1].shape
# Showing reshaped image
plt.imshow(mnist.train.images[1].reshape(28, 28))
# Showing the image in gist gray scale
plt.imshow(mnist.train.images[1].reshape(28, 28),
cmap = 'gist_gray')
mnist.train.images[1].max()
plt.imshow(mnist.train.images[1].reshape(784, 1))
plt.imshow(mnist.train.images[1].reshape(784, 1),
cmap = 'gist_gray',
aspect = 0.02)
Explanation: Visualizing the Data
End of explanation
# Initializing a Placeholder of shape None (number of inputs) by 784
# Tensorflow requires float32
x = tf.placeholder(tf.float32,
shape = [None, 784])
# Initializing weights between the input layer and the output layer
# It is of shape number_of_features by number_of_neurons_in_the_layer
# Initializing with zeros, which is meh, but we will use it for simplicity
# 10 because 0-9 possible numbers
W = tf.Variable(tf.zeros([784, 10]))
# Initializing biases
b = tf.Variable(tf.zeros([10]))
# Create the Graph
y = tf.matmul(x, W) + b
Explanation: Create the Model
End of explanation
# Initializing a Placeholder of shape None (number of inputs) by number_of_classes
y_true = tf.placeholder(tf.float32,
shape = [None, 10])
# Cross Entropy
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels = y_true,
logits = y))
# Gradient Descent
optimizer = tf.train.GradientDescentOptimizer(learning_rate = 0.5)
# Minimizing the loss function
train = optimizer.minimize(cross_entropy)
Explanation: Loss and Optimizer
End of explanation
# Intializing all variables
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
# Train the model for 1000 steps on the training set
# Using built in batch feeder from mnist for convenience
for step in range(1000):
# Training on a batch of 100 examples
batch_x , batch_y = mnist.train.next_batch(100)
sess.run(train, feed_dict = {x : batch_x,
y_true : batch_y})
# Calculating the number of matches
matches = tf.equal(tf.argmax(y, 1),
tf.argmax(y_true, 1))
acc = tf.reduce_mean(tf.cast(matches, tf.float32))
# Calculating the accuracy
print(sess.run(acc, feed_dict = {x : mnist.test.images,
y_true : mnist.test.labels}))
Explanation: Create Session
End of explanation |
3,441 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Data Preparation using pandas
An initial step in statistical data analysis is the preparation of the data to be used in the analysis. In practice, ~~a little~~ ~~some~~ ~~much~~ the majority of the actual time spent on a statistical modeling project is typically devoted to importing, cleaning, validating and transforming the dataset.
This section will introduce pandas, an important third-party Python package for data analysis, as a tool for data preparation, and provide some general advice for what should or should not be done to data before it is analyzed.
Introduction to pandas
pandas is a Python package providing fast, flexible, and expressive data structures designed to work with relational or labeled data both. It is a fundamental high-level building block for doing practical, real world data analysis in Python.
pandas is well suited for
Step1: If an index is not specified, a default sequence of integers is assigned as the index. A NumPy array comprises the values of the Series, while the index is a pandas Index object.
Step2: We can assign meaningful labels to the index, if they are available. These counts are of bacteria taxa constituting the microbiome of hospital patients, so using the taxon of each bacterium is a useful index.
Step3: These labels can be used to refer to the values in the Series.
Step4: Notice that the indexing operation preserved the association between the values and the corresponding indices.
We can still use positional indexing if we wish.
Step5: We can give both the array of values and the index meaningful labels themselves
Step6: NumPy's math functions and other operations can be applied to Series without losing the data structure.
Step7: We can also filter according to the values in the Series
Step8: A Series can be thought of as an ordered key-value store. In fact, we can create one from a dict
Step9: Notice that the Series is created in key-sorted order.
If we pass a custom index to Series, it will select the corresponding values from the dict, and treat indices without corrsponding values as missing. pandas uses the NaN (not a number) type for missing values.
Step10: Critically, the labels are used to align data when used in operations with other Series objects
Step11: Contrast this with NumPy arrays, where arrays of the same length will combine values element-wise; adding Series combined values with the same label in the resulting series. Notice also that the missing values were propogated by addition.
DataFrame
Inevitably, we want to be able to store, view and manipulate data that is multivariate, where for every index there are multiple fields or columns of data, often of varying data type.
A DataFrame is a tabular data structure, encapsulating multiple series like columns in a spreadsheet. Data are stored internally as a 2-dimensional object, but the DataFrame allows us to represent and manipulate higher-dimensional data.
Step12: Notice the DataFrame is sorted by column name. We can change the order by indexing them in the order we desire
Step13: A DataFrame has a second index, representing the columns
Step14: If we wish to access columns, we can do so either by dict-like indexing or by attribute
Step15: Using the standard indexing syntax for a single column of data from a DataFrame returns the column as a Series.
Step16: Passing the column name as a list returns the column as a DataFrame instead.
Step17: Notice that indexing works differently with a DataFrame than with a Series, where in the latter, dict-like indexing retrieved a particular element (row). If we want access to a row in a DataFrame, we index its ix attribute.
Step18: Since a row potentially contains different data types, the returned Series of values is of the generic object type.
If we want to create a DataFrame row-wise rather than column-wise, we can do so with a dict of dicts
Step19: However, we probably want this transposed
Step20: Views
Its important to note that the Series returned when a DataFrame is indexed is merely a view on the DataFrame, and not a copy of the data itself. So you must be cautious when manipulating this data.
For example, let's isolate a column of our dataset by assigning it as a Series to a variable.
Step21: Now, let's assign a new value to one of the elements of the Series.
Step22: However, we may not anticipate that the value in the original DataFrame has also been changed!
Step23: We can avoid this by working with a copy when modifying subsets of the original data.
Step24: So, as we have seen, we can create or modify columns by assignment; let's put back the value we accidentally changed.
Step25: Or, we may wish to add a column representing the year the data were collected.
Step26: But note, we cannot use the attribute indexing method to add a new column
Step27: Auto-alignment
When adding a column that is not a simple constant, we need to be a bit more careful. Due to pandas' auto-alignment behavior, specifying a Series as a new column causes its values to be added according to the DataFrame's index
Step28: Other Python data structures (ones without an index) need to be the same length as the DataFrame
Step29: We can use del to remove columns, in the same way dict entries can be removed
Step30: Or employ the drop method.
Step31: We can extract the underlying data as a simple ndarray by accessing the values attribute
Step32: Notice that because of the mix of string, integer and float (and NaN) values, the dtype of the array is object. The dtype will automatically be chosen to be as general as needed to accomodate all the columns.
Step33: pandas uses a custom data structure to represent the indices of Series and DataFrames.
Step34: Index objects are immutable
Step35: This is so that Index objects can be shared between data structures without fear that they will be changed.
Step36: Excercise
Step37: Using pandas
This section, we will import and clean up some of the datasets that we will be using later on in the tutorial. And in doing so, we will introduce the key functionality of pandas that is required to use the software effectively.
Importing data
A key, but often under-appreciated, step in data analysis is importing the data that we wish to analyze. Though it is easy to load basic data structures into Python using built-in tools or those provided by packages like NumPy, it is non-trivial to import structured data well, and to easily convert this input into a robust data structure
Step38: This table can be read into a DataFrame using read_table.
Step39: There is no header row in this dataset, so we specified this, and provided our own header names. If we did not specify header=None the function would have assumed the first row contained column names.
The tab separator was passed to the sep argument as \t.
The sep argument can be customized as needed to accomodate arbitrary separators. For example, we can use a regular expression to define a variable amount of whitespace, which is unfortunately common in some datasets
Step40: There is typically some cleanup that is required of the returned data, such as the assignment of column names or conversion of types.
The table of interest is at index 1, and we will extract two columns from the table. Otherwise, this table is pretty clean.
Step41: We can create an indicator (binary) variable for OECD status by checking if each country is in the index of countries with membership year less than 1997.
The new DataFrame method assign is a convenient means for creating the new column from this operation.
Step42: Since the distribution of populations spans several orders of magnitude, we may wish to use the logarithm of the population size, which may be created similarly.
Step43: The NumPy log function will return a pandas Series (or DataFrame when applied to one) instead of a ndarray; all of NumPy's functions are compatible with pandas in this way.
Step44: Comma-separated Values (CSV)
The most common form of delimited data is comma-separated values (CSV). Since CSV is so ubiquitous, the read_csv is available as a convenience function for read_table.
Consider some more microbiome data.
Step45: This table can be read into a DataFrame using read_csv
Step46: If we have sections of data that we do not wish to import (for example, known bad data), we can populate the skiprows argument
Step47: Conversely, if we only want to import a small number of rows from, say, a very large data file we can use nrows
Step48: Alternately, if we want to process our data in reasonable chunks, the chunksize argument will return an iterable object that can be employed in a data processing loop. For example, our microbiome data are organized by bacterial phylum, with 15 patients represented in each
Step49: Exercise
Step50: Hierarchical Indices
For a more useful index, we can specify the first two columns, which together provide a unique index to the data.
Step51: This is called a hierarchical index, which allows multiple dimensions of data to be represented in tabular form.
Step52: The corresponding index is a MultiIndex object that consists of a sequence of tuples, the elements of which is some combination of the three columns used to create the index. Where there are multiple repeated values, pandas does not print the repeats, making it easy to identify groups of values.
Rows can be indexed by passing the appropriate tuple.
Step53: With a hierachical index, we can select subsets of the data based on a partial index
Step54: To extract arbitrary levels from a hierarchical row index, the cross-section method xs can be used.
Step55: We may also reorder levels as we like.
Step56: Operations
DataFrame and Series objects allow for several operations to take place either on a single object, or between two or more objects.
For example, we can perform arithmetic on the elements of two objects, such as calculating the ratio of bacteria counts between locations
Step57: Microsoft Excel
Since so much financial and scientific data ends up in Excel spreadsheets (regrettably), pandas' ability to directly import Excel spreadsheets is valuable. This support is contingent on having one or two dependencies (depending on what version of Excel file is being imported) installed
Step58: Then, since modern spreadsheets consist of one or more "sheets", we parse the sheet with the data of interest
Step59: There is now a read_excel conveneince function in pandas that combines these steps into a single call
Step60: Relational Databases
If you are fortunate, your data will be stored in a database (relational or non-relational) rather than in arbitrary text files or spreadsheet. Relational databases are particularly useful for storing large quantities of structured data, where fields are grouped together in tables according to their relationships with one another.
pandas' DataFrame interacts with relational (i.e. SQL) databases, and even provides facilties for using SQL syntax on the DataFrame itself, which we will get to later. For now, let's work with a ubiquitous embedded database called SQLite, which comes bundled with Python. A SQLite database can be queried with the standard library's sqlite3 module.
Step61: This query string will create a table to hold some of our microbiome data, which we can execute after connecting to a database (which will be created, if it does not exist).
Step62: Using SELECT queries, we can read from the database.
Step63: These results can be passed directly to a DataFrame
Step64: To obtain the column names, we can obtain the table information from the database, via the special PRAGMA statement.
Step65: A more direct approach is to pass the query to the read_sql_query functon, which returns a populated `DataFrame.
Step66: Correspondingly, we can append records into the database with to_sql.
Step67: There are several other data formats that can be imported into Python and converted into DataFrames, with the help of buitl-in or third-party libraries. These include JSON, XML, HDF5, non-relational databases, and various web APIs.
Step68: 2014 Ebola Outbreak Data
The ../data/ebola folder contains summarized reports of Ebola cases from three countries during the recent outbreak of the disease in West Africa. For each country, there are daily reports that contain various information about the outbreak in several cities in each country.
From these data files, use pandas to import them and create a single data frame that includes the daily totals of new cases for each country.
We may use this compiled data for more advaned applications later in the course.
The data are taken from Caitlin Rivers' ebola GitHub repository, and are licenced for both commercial and non-commercial use. The tutorial repository contains a subset of this data from three countries (Sierra Leone, Liberia and Guinea) that we will use as an example. They reside in a nested subdirectory in the data directory.
Step69: Within each country directory, there are CSV files containing daily information regarding the state of the outbreak for that country. The first step is to efficiently import all the relevant files.
Our approach will be to construct a dictionary containing a list of filenames to import. We can use the glob package to identify all the CSV files in each directory. This can all be placed within a dictionary comprehension.
Step70: We are now in a position to iterate over the dictionary and import the corresponding files. However, the data layout of the files across the dataset is partially inconsistent.
Step71: Clearly, we will need to develop row masks to extract the data we need across all files, without having to manually extract data from each file.
Let's hack at one file to develop the mask.
Step72: To prevent issues with capitalization, we will simply revert all labels to lower case.
Step73: Since we are interested in extracting new cases only, we can use the string accessor attribute to look for key words that we would like to include or exclude.
Step74: We could have instead used regular expressions to do the same thing.
Finally, we are only interested in three columns.
Step75: We can now embed this operation in a loop over all the filenames in the database.
Step76: Now that we have a list populated with DataFrame objects for each day and country, we can call concat to concatenate them into a single DataFrame.
Step77: This works because the structure of each table was identical
Manipulating indices
Notice from above, however, that the index contains redundant integer index values. We can confirm this
Step78: We can create a new unique index by calling the reset_index method on the new data frame after we import it, which will generate a new ordered, unique index.
Step79: Reindexing allows users to manipulate the data labels in a DataFrame. It forces a DataFrame to conform to the new index, and optionally, fill in missing data if requested.
A simple use of reindex is to alter the order of the rows. For example, records are currently ordered first by country then by day, since this is the order in which they were iterated over and imported. We might arbitrarily want to reverse the order, which is performed by passing the appropriate index values to reindex.
Step80: Notice that the reindexing operation is not performed "in-place"; the original DataFrame remains as it was, and the method returns a copy of the DataFrame with the new index. This is a common trait for pandas, and is a Good Thing.
We may also wish to reorder the columns this way.
Step81: Group by operations
One of pandas' most powerful features is the ability to perform operations on subgroups of a DataFrame. These so-called group by operations defines subunits of the dataset according to the values of one or more variabes in the DataFrame.
For this data, we want to sum the new case counts by day and country; so we pass these two column names to the groupby method, then sum the totals column accross them.
Step82: The resulting series retains a hierarchical index from the group by operation. Hence, we can index out the counts for a given country on a particular day by indexing with the appropriate tuple.
Step83: One issue with the data we have extracted is that there appear to be serious outliers in the Liberian counts. The values are much too large to be a daily count, even during a serious outbreak.
Step84: We can filter these outliers using an appropriate threshold.
Step85: Plotting
pandas data structures have high-level methods for creating a variety of plots, which tends to be easier than generating the corresponding plot using matplotlib.
For example, we may want to create a plot of the cumulative cases for each of the three countries. The easiest way to do this is to remove the hierarchical index, and create a DataFrame of three columns, which will result in three lines when plotted.
First, call unstack to remove the hierarichical index
Step86: Next, transpose the resulting DataFrame to swap the rows and columns.
Step87: Since we have missing values for some dates, we will assume that the counts for those days were zero (the actual counts for that day may have bee included in the next reporting day's data).
Step88: Finally, calculate the cumulative sum for all the columns, and generate a line plot, which we get by default.
Step89: Resampling
An alternative to filling days without case reports with zeros is to aggregate the data at a coarser time scale. New cases are often reported by week; we can use the resample method to summarize the data into weekly values.
Step90: Writing Data to Files
As well as being able to read several data input formats, pandas can also export data to a variety of storage formats. We will bring your attention to just one of these, but the usage is similar across formats.
Step91: The to_csv method writes a DataFrame to a comma-separated values (csv) file. You can specify custom delimiters (via sep argument), how missing values are written (via na_rep argument), whether the index is writen (via index argument), whether the header is included (via header argument), among other options.
Missing data
The occurence of missing data is so prevalent that it pays to use tools like pandas, which seamlessly integrates missing data handling so that it can be dealt with easily, and in the manner required by the analysis at hand.
Missing data are represented in Series and DataFrame objects by the NaN floating point value. However, None is also treated as missing, since it is commonly used as such in other contexts (e.g. NumPy).
Step92: Above, pandas recognized NA and an empty field as missing data.
Step93: Unfortunately, there will sometimes be inconsistency with the conventions for missing data. In this example, there is a question mark "?" and a large negative number where there should have been a positive integer. We can specify additional symbols with the na_values argument
Step94: These can be specified on a column-wise basis using an appropriate dict as the argument for na_values.
By default, dropna drops entire rows in which one or more values are missing.
Step95: If we want to drop missing values column-wise instead of row-wise, we use axis=1.
Step96: Rather than omitting missing data from an analysis, in some cases it may be suitable to fill the missing value in, either with a default value (such as zero), a sentinel value, or a value that is either imputed or carried forward/backward from similar data points. We can do this programmatically in pandas with the fillna argument.
Step97: Sentinel values are useful in pandas because missing values are treated as floats, so it is impossible to use explicit missing values with integer columns. Using some large (positive or negative) integer as a sentinel value will allow the column to be integer typed.
Exercise | Python Code:
counts = pd.Series([632, 1638, 569, 115])
counts
Explanation: Data Preparation using pandas
An initial step in statistical data analysis is the preparation of the data to be used in the analysis. In practice, ~~a little~~ ~~some~~ ~~much~~ the majority of the actual time spent on a statistical modeling project is typically devoted to importing, cleaning, validating and transforming the dataset.
This section will introduce pandas, an important third-party Python package for data analysis, as a tool for data preparation, and provide some general advice for what should or should not be done to data before it is analyzed.
Introduction to pandas
pandas is a Python package providing fast, flexible, and expressive data structures designed to work with relational or labeled data both. It is a fundamental high-level building block for doing practical, real world data analysis in Python.
pandas is well suited for:
Tabular data with heterogeneously-typed columns, as you might find in an SQL table or Excel spreadsheet
Ordered and unordered (not necessarily fixed-frequency) time series data.
Arbitrary matrix data with row and column labels
Virtually any statistical dataset, labeled or unlabeled, can be converted to a pandas data structure for cleaning, transformation, and analysis.
Key features
Easy handling of missing data
Size mutability: columns can be inserted and deleted from DataFrame and higher dimensional objects
Automatic and explicit data alignment: objects can be explicitly aligned to a set of labels, or the data can be aligned automatically
Powerful, flexible group by functionality to perform split-apply-combine operations on data sets
Intelligent label-based slicing, fancy indexing, and subsetting of large data sets
Intuitive merging and joining data sets
Flexible reshaping and pivoting of data sets
Hierarchical labeling of axes
Robust IO tools for loading data from flat files, Excel files, databases, and HDF5
Time series functionality: date range generation and frequency conversion, moving window statistics, moving window linear regressions, date shifting and lagging, etc.
Series
A Series is a single vector of data (like a NumPy array) with an index that labels each element in the vector.
End of explanation
counts.values
counts.index
Explanation: If an index is not specified, a default sequence of integers is assigned as the index. A NumPy array comprises the values of the Series, while the index is a pandas Index object.
End of explanation
bacteria = pd.Series([632, 1638, 569, 115],
index=['Firmicutes', 'Proteobacteria', 'Actinobacteria', 'Bacteroidetes'])
bacteria
Explanation: We can assign meaningful labels to the index, if they are available. These counts are of bacteria taxa constituting the microbiome of hospital patients, so using the taxon of each bacterium is a useful index.
End of explanation
bacteria['Actinobacteria']
bacteria[bacteria.index.str.endswith('bacteria')]
'Bacteroidetes' in bacteria
Explanation: These labels can be used to refer to the values in the Series.
End of explanation
bacteria[0]
Explanation: Notice that the indexing operation preserved the association between the values and the corresponding indices.
We can still use positional indexing if we wish.
End of explanation
bacteria.name = 'counts'
bacteria.index.name = 'phylum'
bacteria
Explanation: We can give both the array of values and the index meaningful labels themselves:
End of explanation
np.log(bacteria)
Explanation: NumPy's math functions and other operations can be applied to Series without losing the data structure.
End of explanation
bacteria[bacteria>1000]
Explanation: We can also filter according to the values in the Series:
End of explanation
bacteria_dict = {'Firmicutes': 632, 'Proteobacteria': 1638, 'Actinobacteria': 569, 'Bacteroidetes': 115}
bact = pd.Series(bacteria_dict)
bact
Explanation: A Series can be thought of as an ordered key-value store. In fact, we can create one from a dict:
End of explanation
bacteria2 = pd.Series(bacteria_dict,
index=['Cyanobacteria','Firmicutes','Proteobacteria','Actinobacteria'])
bacteria2
bacteria2.isnull()
Explanation: Notice that the Series is created in key-sorted order.
If we pass a custom index to Series, it will select the corresponding values from the dict, and treat indices without corrsponding values as missing. pandas uses the NaN (not a number) type for missing values.
End of explanation
bacteria + bacteria2
Explanation: Critically, the labels are used to align data when used in operations with other Series objects:
End of explanation
bacteria_data = pd.DataFrame({'value':[632, 1638, 569, 115, 433, 1130, 754, 555],
'patient':[1, 1, 1, 1, 2, 2, 2, 2],
'phylum':['Firmicutes', 'Proteobacteria', 'Actinobacteria',
'Bacteroidetes', 'Firmicutes', 'Proteobacteria', 'Actinobacteria', 'Bacteroidetes']})
bacteria_data
Explanation: Contrast this with NumPy arrays, where arrays of the same length will combine values element-wise; adding Series combined values with the same label in the resulting series. Notice also that the missing values were propogated by addition.
DataFrame
Inevitably, we want to be able to store, view and manipulate data that is multivariate, where for every index there are multiple fields or columns of data, often of varying data type.
A DataFrame is a tabular data structure, encapsulating multiple series like columns in a spreadsheet. Data are stored internally as a 2-dimensional object, but the DataFrame allows us to represent and manipulate higher-dimensional data.
End of explanation
bacteria_data[['phylum','value','patient']]
Explanation: Notice the DataFrame is sorted by column name. We can change the order by indexing them in the order we desire:
End of explanation
bacteria_data.columns
Explanation: A DataFrame has a second index, representing the columns:
End of explanation
bacteria_data['value']
bacteria_data.value
Explanation: If we wish to access columns, we can do so either by dict-like indexing or by attribute:
End of explanation
type(bacteria_data['value'])
Explanation: Using the standard indexing syntax for a single column of data from a DataFrame returns the column as a Series.
End of explanation
bacteria_data[['value']]
Explanation: Passing the column name as a list returns the column as a DataFrame instead.
End of explanation
bacteria_data.ix[3]
Explanation: Notice that indexing works differently with a DataFrame than with a Series, where in the latter, dict-like indexing retrieved a particular element (row). If we want access to a row in a DataFrame, we index its ix attribute.
End of explanation
bacteria_data = pd.DataFrame({0: {'patient': 1, 'phylum': 'Firmicutes', 'value': 632},
1: {'patient': 1, 'phylum': 'Proteobacteria', 'value': 1638},
2: {'patient': 1, 'phylum': 'Actinobacteria', 'value': 569},
3: {'patient': 1, 'phylum': 'Bacteroidetes', 'value': 115},
4: {'patient': 2, 'phylum': 'Firmicutes', 'value': 433},
5: {'patient': 2, 'phylum': 'Proteobacteria', 'value': 1130},
6: {'patient': 2, 'phylum': 'Actinobacteria', 'value': 754},
7: {'patient': 2, 'phylum': 'Bacteroidetes', 'value': 555}})
bacteria_data
Explanation: Since a row potentially contains different data types, the returned Series of values is of the generic object type.
If we want to create a DataFrame row-wise rather than column-wise, we can do so with a dict of dicts:
End of explanation
bacteria_data = bacteria_data.T
bacteria_data
Explanation: However, we probably want this transposed:
End of explanation
vals = bacteria_data.value
vals
Explanation: Views
Its important to note that the Series returned when a DataFrame is indexed is merely a view on the DataFrame, and not a copy of the data itself. So you must be cautious when manipulating this data.
For example, let's isolate a column of our dataset by assigning it as a Series to a variable.
End of explanation
vals[5] = 0
vals
Explanation: Now, let's assign a new value to one of the elements of the Series.
End of explanation
bacteria_data
Explanation: However, we may not anticipate that the value in the original DataFrame has also been changed!
End of explanation
vals = bacteria_data.value.copy()
vals[5] = 1000
bacteria_data
Explanation: We can avoid this by working with a copy when modifying subsets of the original data.
End of explanation
bacteria_data.value[5] = 1130
Explanation: So, as we have seen, we can create or modify columns by assignment; let's put back the value we accidentally changed.
End of explanation
bacteria_data['year'] = 2013
bacteria_data
Explanation: Or, we may wish to add a column representing the year the data were collected.
End of explanation
bacteria_data.treatment = 1
bacteria_data
bacteria_data.treatment
Explanation: But note, we cannot use the attribute indexing method to add a new column:
End of explanation
treatment = pd.Series([0]*4 + [1]*2)
treatment
bacteria_data['treatment'] = treatment
bacteria_data
Explanation: Auto-alignment
When adding a column that is not a simple constant, we need to be a bit more careful. Due to pandas' auto-alignment behavior, specifying a Series as a new column causes its values to be added according to the DataFrame's index:
End of explanation
month = ['Jan', 'Feb', 'Mar', 'Apr']
bacteria_data['month'] = month
bacteria_data['month'] = ['Jan']*len(bacteria_data)
bacteria_data
Explanation: Other Python data structures (ones without an index) need to be the same length as the DataFrame:
End of explanation
del bacteria_data['month']
bacteria_data
Explanation: We can use del to remove columns, in the same way dict entries can be removed:
End of explanation
bacteria_data.drop('treatment', axis=1)
Explanation: Or employ the drop method.
End of explanation
bacteria_data.values
Explanation: We can extract the underlying data as a simple ndarray by accessing the values attribute:
End of explanation
df = pd.DataFrame({'foo': [1,2,3], 'bar':[0.4, -1.0, 4.5]})
df.values, df.values.dtype
Explanation: Notice that because of the mix of string, integer and float (and NaN) values, the dtype of the array is object. The dtype will automatically be chosen to be as general as needed to accomodate all the columns.
End of explanation
bacteria_data.index
Explanation: pandas uses a custom data structure to represent the indices of Series and DataFrames.
End of explanation
bacteria_data.index[0] = 15
Explanation: Index objects are immutable:
End of explanation
bacteria2.index = bacteria.index
bacteria2
Explanation: This is so that Index objects can be shared between data structures without fear that they will be changed.
End of explanation
# Write your answer here
Explanation: Excercise: Indexing
From the bacteria_data table above, create an index to return all rows for which the phylum name ends in "bacteria" and the value is greater than 1000.
End of explanation
!head ../data/olympics.1996.txt
Explanation: Using pandas
This section, we will import and clean up some of the datasets that we will be using later on in the tutorial. And in doing so, we will introduce the key functionality of pandas that is required to use the software effectively.
Importing data
A key, but often under-appreciated, step in data analysis is importing the data that we wish to analyze. Though it is easy to load basic data structures into Python using built-in tools or those provided by packages like NumPy, it is non-trivial to import structured data well, and to easily convert this input into a robust data structure:
genes = np.loadtxt("genes.csv", delimiter=",", dtype=[('gene', '|S10'), ('value', '<f4')])
pandas provides a convenient set of functions for importing tabular data in a number of formats directly into a DataFrame object. These functions include a slew of options to perform type inference, indexing, parsing, iterating and cleaning automatically as data are imported.
Delimited data
The file olympics.1996.txt in the data directory contains counts of medals awarded at the 1996 Summer Olympic Games by country, along with the countries' respective population sizes. This data is stored in a tab-separated format.
End of explanation
medals = pd.read_table('../data/olympics.1996.txt', sep='\t',
index_col=0,
header=None, names=['country', 'medals', 'population'])
medals.head()
Explanation: This table can be read into a DataFrame using read_table.
End of explanation
oecd_site = 'http://www.oecd.org/about/membersandpartners/list-oecd-member-countries.htm'
pd.read_html(oecd_site)
Explanation: There is no header row in this dataset, so we specified this, and provided our own header names. If we did not specify header=None the function would have assumed the first row contained column names.
The tab separator was passed to the sep argument as \t.
The sep argument can be customized as needed to accomodate arbitrary separators. For example, we can use a regular expression to define a variable amount of whitespace, which is unfortunately common in some datasets:
sep='\s+'
Scraping Data from the Web
We would like to add another variable to this dataset. Along with population, a country's economic development may be a useful predictor of Olympic success. A very simple indicator of this might be OECD membership status.
The OECD website contains a table listing OECD member nations, along with its year of membership. We would like to import this table and extract the contries that were members as of the 1996 games.
The read_html function accepts a URL argument, and will attempt to extract all the tables from that address, returning whatever it finds in a list of DataFrames.
End of explanation
oecd = pd.read_html(oecd_site, header=0)[1][[1,2]]
oecd.head()
oecd['year'] = pd.to_datetime(oecd.Date).apply(lambda x: x.year)
oecd_year = oecd.set_index(oecd.Country.str.title())['year'].dropna()
oecd_year
Explanation: There is typically some cleanup that is required of the returned data, such as the assignment of column names or conversion of types.
The table of interest is at index 1, and we will extract two columns from the table. Otherwise, this table is pretty clean.
End of explanation
medals_data = medals.assign(oecd=medals.index.isin((oecd_year[oecd_year<1997]).index).astype(int))
Explanation: We can create an indicator (binary) variable for OECD status by checking if each country is in the index of countries with membership year less than 1997.
The new DataFrame method assign is a convenient means for creating the new column from this operation.
End of explanation
medals_data = medals_data.assign(log_population=np.log(medals.population))
Explanation: Since the distribution of populations spans several orders of magnitude, we may wish to use the logarithm of the population size, which may be created similarly.
End of explanation
medals_data.head()
Explanation: The NumPy log function will return a pandas Series (or DataFrame when applied to one) instead of a ndarray; all of NumPy's functions are compatible with pandas in this way.
End of explanation
!cat ../data/microbiome/microbiome.csv
Explanation: Comma-separated Values (CSV)
The most common form of delimited data is comma-separated values (CSV). Since CSV is so ubiquitous, the read_csv is available as a convenience function for read_table.
Consider some more microbiome data.
End of explanation
mb = pd.read_csv("../data/microbiome/microbiome.csv")
mb.head()
Explanation: This table can be read into a DataFrame using read_csv:
End of explanation
pd.read_csv("../data/microbiome/microbiome.csv", skiprows=[3,4,6]).head()
Explanation: If we have sections of data that we do not wish to import (for example, known bad data), we can populate the skiprows argument:
End of explanation
few_recs = pd.read_csv("../data/microbiome/microbiome.csv", nrows=4)
few_recs
Explanation: Conversely, if we only want to import a small number of rows from, say, a very large data file we can use nrows:
End of explanation
data_chunks = pd.read_csv("../data/microbiome/microbiome.csv", chunksize=15)
data_chunks
Explanation: Alternately, if we want to process our data in reasonable chunks, the chunksize argument will return an iterable object that can be employed in a data processing loop. For example, our microbiome data are organized by bacterial phylum, with 15 patients represented in each:
End of explanation
# Write your answer here
Explanation: Exercise: Calculating summary statistics
Import the microbiome data, calculating the mean counts across all patients for each taxon, returning these values in a dictionary.
Hint: using chunksize makes this more efficent!
End of explanation
mb = pd.read_csv("../data/microbiome/microbiome.csv", index_col=['Taxon','Patient'])
mb.head()
Explanation: Hierarchical Indices
For a more useful index, we can specify the first two columns, which together provide a unique index to the data.
End of explanation
mb.index
Explanation: This is called a hierarchical index, which allows multiple dimensions of data to be represented in tabular form.
End of explanation
mb.ix[('Firmicutes', 2)]
Explanation: The corresponding index is a MultiIndex object that consists of a sequence of tuples, the elements of which is some combination of the three columns used to create the index. Where there are multiple repeated values, pandas does not print the repeats, making it easy to identify groups of values.
Rows can be indexed by passing the appropriate tuple.
End of explanation
mb.ix['Proteobacteria']
Explanation: With a hierachical index, we can select subsets of the data based on a partial index:
End of explanation
mb.xs(1, level='Patient')
Explanation: To extract arbitrary levels from a hierarchical row index, the cross-section method xs can be used.
End of explanation
mb.swaplevel('Patient', 'Taxon').head()
Explanation: We may also reorder levels as we like.
End of explanation
mb.Stool / mb.Tissue
Explanation: Operations
DataFrame and Series objects allow for several operations to take place either on a single object, or between two or more objects.
For example, we can perform arithmetic on the elements of two objects, such as calculating the ratio of bacteria counts between locations:
End of explanation
mb_file = pd.ExcelFile('../data/microbiome/MID1.xls')
mb_file
Explanation: Microsoft Excel
Since so much financial and scientific data ends up in Excel spreadsheets (regrettably), pandas' ability to directly import Excel spreadsheets is valuable. This support is contingent on having one or two dependencies (depending on what version of Excel file is being imported) installed: xlrd and openpyxl (these may be installed with either pip or easy_install).
Importing Excel data to pandas is a two-step process. First, we create an ExcelFile object using the path of the file:
End of explanation
mb1 = mb_file.parse("Sheet 1", header=None)
mb1.columns = ["Taxon", "Count"]
mb1.head()
Explanation: Then, since modern spreadsheets consist of one or more "sheets", we parse the sheet with the data of interest:
End of explanation
mb2 = pd.read_excel('../data/microbiome/MID2.xls', sheetname='Sheet 1', header=None)
mb2.head()
Explanation: There is now a read_excel conveneince function in pandas that combines these steps into a single call:
End of explanation
import sqlite3
query = '''
CREATE TABLE samples
(taxon VARCHAR(15), patient INTEGER, tissue INTEGER, stool INTEGER);
'''
Explanation: Relational Databases
If you are fortunate, your data will be stored in a database (relational or non-relational) rather than in arbitrary text files or spreadsheet. Relational databases are particularly useful for storing large quantities of structured data, where fields are grouped together in tables according to their relationships with one another.
pandas' DataFrame interacts with relational (i.e. SQL) databases, and even provides facilties for using SQL syntax on the DataFrame itself, which we will get to later. For now, let's work with a ubiquitous embedded database called SQLite, which comes bundled with Python. A SQLite database can be queried with the standard library's sqlite3 module.
End of explanation
con = sqlite3.connect('microbiome.sqlite3')
con.execute(query)
con.commit()
few_recs.ix[0]
con.execute('INSERT INTO samples VALUES(\'{}\',{},{},{})'.format(*few_recs.ix[0]))
query = 'INSERT INTO samples VALUES(?, ?, ?, ?)'
con.executemany(query, few_recs.values[1:])
con.commit()
Explanation: This query string will create a table to hold some of our microbiome data, which we can execute after connecting to a database (which will be created, if it does not exist).
End of explanation
cursor = con.execute('SELECT * FROM samples')
rows = cursor.fetchall()
rows
Explanation: Using SELECT queries, we can read from the database.
End of explanation
pd.DataFrame(rows)
Explanation: These results can be passed directly to a DataFrame
End of explanation
table_info = con.execute('PRAGMA table_info(samples);').fetchall()
table_info
pd.DataFrame(rows, columns=np.transpose(table_info)[1])
Explanation: To obtain the column names, we can obtain the table information from the database, via the special PRAGMA statement.
End of explanation
pd.read_sql_query('SELECT * FROM samples', con)
Explanation: A more direct approach is to pass the query to the read_sql_query functon, which returns a populated `DataFrame.
End of explanation
more_recs = pd.read_csv("../data/microbiome/microbiome_missing.csv").head(20)
more_recs.to_sql('samples', con, if_exists='append', index=False)
cursor = con.execute('SELECT * FROM samples')
cursor.fetchall()
Explanation: Correspondingly, we can append records into the database with to_sql.
End of explanation
# Get rid of the database we created
!rm microbiome.sqlite3
Explanation: There are several other data formats that can be imported into Python and converted into DataFrames, with the help of buitl-in or third-party libraries. These include JSON, XML, HDF5, non-relational databases, and various web APIs.
End of explanation
ebola_dirs = !ls ../data/ebola/
ebola_dirs
Explanation: 2014 Ebola Outbreak Data
The ../data/ebola folder contains summarized reports of Ebola cases from three countries during the recent outbreak of the disease in West Africa. For each country, there are daily reports that contain various information about the outbreak in several cities in each country.
From these data files, use pandas to import them and create a single data frame that includes the daily totals of new cases for each country.
We may use this compiled data for more advaned applications later in the course.
The data are taken from Caitlin Rivers' ebola GitHub repository, and are licenced for both commercial and non-commercial use. The tutorial repository contains a subset of this data from three countries (Sierra Leone, Liberia and Guinea) that we will use as an example. They reside in a nested subdirectory in the data directory.
End of explanation
import glob
filenames = {data_dir[:data_dir.find('_')]: glob.glob('../data/ebola/{0}/*.csv'.format(data_dir)) for data_dir in ebola_dirs[1:]}
Explanation: Within each country directory, there are CSV files containing daily information regarding the state of the outbreak for that country. The first step is to efficiently import all the relevant files.
Our approach will be to construct a dictionary containing a list of filenames to import. We can use the glob package to identify all the CSV files in each directory. This can all be placed within a dictionary comprehension.
End of explanation
pd.read_csv('../data/ebola/sl_data/2014-08-12-v77.csv').head()
pd.read_csv('../data/ebola/guinea_data/2014-09-02.csv').head()
Explanation: We are now in a position to iterate over the dictionary and import the corresponding files. However, the data layout of the files across the dataset is partially inconsistent.
End of explanation
sample = pd.read_csv('../data/ebola/sl_data/2014-08-12-v77.csv')
Explanation: Clearly, we will need to develop row masks to extract the data we need across all files, without having to manually extract data from each file.
Let's hack at one file to develop the mask.
End of explanation
lower_vars = sample.variable.str.lower()
Explanation: To prevent issues with capitalization, we will simply revert all labels to lower case.
End of explanation
case_mask = (lower_vars.str.contains('new')
& (lower_vars.str.contains('case') | lower_vars.str.contains('suspect'))
& ~lower_vars.str.contains('non')
& ~lower_vars.str.contains('total'))
Explanation: Since we are interested in extracting new cases only, we can use the string accessor attribute to look for key words that we would like to include or exclude.
End of explanation
sample.loc[case_mask, ['date', 'variable', 'National']]
Explanation: We could have instead used regular expressions to do the same thing.
Finally, we are only interested in three columns.
End of explanation
datasets = []
for country in filenames:
country_files = filenames[country]
for f in country_files:
data = pd.read_csv(f)
# Convert to lower case to avoid capitalization issues
data.columns = data.columns.str.lower()
# Column naming is inconsistent. These procedures deal with that.
keep_columns = ['date']
if 'description' in data.columns:
keep_columns.append('description')
else:
keep_columns.append('variable')
if 'totals' in data.columns:
keep_columns.append('totals')
else:
keep_columns.append('national')
# Index out the columns we need, and rename them
keep_data = data[keep_columns]
keep_data.columns = 'date', 'variable', 'totals'
# Extract the rows we might want
lower_vars = keep_data.variable.str.lower()
# Of course we can also use regex to do this
case_mask = (lower_vars.str.contains('new')
& (lower_vars.str.contains('case') | lower_vars.str.contains('suspect')
| lower_vars.str.contains('confirm'))
& ~lower_vars.str.contains('non')
& ~lower_vars.str.contains('total'))
keep_data = keep_data[case_mask].dropna()
# Convert data types
keep_data['date'] = pd.to_datetime(keep_data.date)
keep_data['totals'] = keep_data.totals.astype(int)
# Assign country label and append to datasets list
datasets.append(keep_data.assign(country=country))
Explanation: We can now embed this operation in a loop over all the filenames in the database.
End of explanation
all_data = pd.concat(datasets)
all_data.head()
Explanation: Now that we have a list populated with DataFrame objects for each day and country, we can call concat to concatenate them into a single DataFrame.
End of explanation
all_data.index.is_unique
Explanation: This works because the structure of each table was identical
Manipulating indices
Notice from above, however, that the index contains redundant integer index values. We can confirm this:
End of explanation
all_data = pd.concat(datasets).reset_index(drop=True)
all_data.head()
Explanation: We can create a new unique index by calling the reset_index method on the new data frame after we import it, which will generate a new ordered, unique index.
End of explanation
all_data.reindex(all_data.index[::-1])
Explanation: Reindexing allows users to manipulate the data labels in a DataFrame. It forces a DataFrame to conform to the new index, and optionally, fill in missing data if requested.
A simple use of reindex is to alter the order of the rows. For example, records are currently ordered first by country then by day, since this is the order in which they were iterated over and imported. We might arbitrarily want to reverse the order, which is performed by passing the appropriate index values to reindex.
End of explanation
all_data.reindex(columns=['date', 'country', 'variable', 'totals']).head()
Explanation: Notice that the reindexing operation is not performed "in-place"; the original DataFrame remains as it was, and the method returns a copy of the DataFrame with the new index. This is a common trait for pandas, and is a Good Thing.
We may also wish to reorder the columns this way.
End of explanation
all_data_grouped = all_data.groupby(['country', 'date'])
daily_cases = all_data_grouped['totals'].sum()
daily_cases.head(10)
Explanation: Group by operations
One of pandas' most powerful features is the ability to perform operations on subgroups of a DataFrame. These so-called group by operations defines subunits of the dataset according to the values of one or more variabes in the DataFrame.
For this data, we want to sum the new case counts by day and country; so we pass these two column names to the groupby method, then sum the totals column accross them.
End of explanation
daily_cases[('liberia', '2014-09-02')]
Explanation: The resulting series retains a hierarchical index from the group by operation. Hence, we can index out the counts for a given country on a particular day by indexing with the appropriate tuple.
End of explanation
daily_cases.sort(ascending=False)
daily_cases.head(10)
Explanation: One issue with the data we have extracted is that there appear to be serious outliers in the Liberian counts. The values are much too large to be a daily count, even during a serious outbreak.
End of explanation
daily_cases = daily_cases[daily_cases<200]
Explanation: We can filter these outliers using an appropriate threshold.
End of explanation
daily_cases.unstack().head()
Explanation: Plotting
pandas data structures have high-level methods for creating a variety of plots, which tends to be easier than generating the corresponding plot using matplotlib.
For example, we may want to create a plot of the cumulative cases for each of the three countries. The easiest way to do this is to remove the hierarchical index, and create a DataFrame of three columns, which will result in three lines when plotted.
First, call unstack to remove the hierarichical index:
End of explanation
daily_cases.unstack().T.head()
Explanation: Next, transpose the resulting DataFrame to swap the rows and columns.
End of explanation
daily_cases.unstack().T.fillna(0).head()
Explanation: Since we have missing values for some dates, we will assume that the counts for those days were zero (the actual counts for that day may have bee included in the next reporting day's data).
End of explanation
daily_cases.unstack().T.fillna(0).cumsum().plot()
Explanation: Finally, calculate the cumulative sum for all the columns, and generate a line plot, which we get by default.
End of explanation
weekly_cases = daily_cases.unstack().T.resample('W', how='sum')
weekly_cases
weekly_cases.cumsum().plot()
Explanation: Resampling
An alternative to filling days without case reports with zeros is to aggregate the data at a coarser time scale. New cases are often reported by week; we can use the resample method to summarize the data into weekly values.
End of explanation
medals_data.to_csv("../data/medals.csv", index=False)
Explanation: Writing Data to Files
As well as being able to read several data input formats, pandas can also export data to a variety of storage formats. We will bring your attention to just one of these, but the usage is similar across formats.
End of explanation
!head -n 20 ../data/microbiome/microbiome_missing.csv
pd.read_csv("../data/microbiome/microbiome_missing.csv").head(20)
Explanation: The to_csv method writes a DataFrame to a comma-separated values (csv) file. You can specify custom delimiters (via sep argument), how missing values are written (via na_rep argument), whether the index is writen (via index argument), whether the header is included (via header argument), among other options.
Missing data
The occurence of missing data is so prevalent that it pays to use tools like pandas, which seamlessly integrates missing data handling so that it can be dealt with easily, and in the manner required by the analysis at hand.
Missing data are represented in Series and DataFrame objects by the NaN floating point value. However, None is also treated as missing, since it is commonly used as such in other contexts (e.g. NumPy).
End of explanation
pd.isnull(pd.read_csv("../data/microbiome/microbiome_missing.csv")).head(20)
Explanation: Above, pandas recognized NA and an empty field as missing data.
End of explanation
missing_sample = pd.read_csv("../data/microbiome/microbiome_missing.csv",
na_values=['?', -99999], nrows=20)
missing_sample
Explanation: Unfortunately, there will sometimes be inconsistency with the conventions for missing data. In this example, there is a question mark "?" and a large negative number where there should have been a positive integer. We can specify additional symbols with the na_values argument:
End of explanation
missing_sample.dropna()
Explanation: These can be specified on a column-wise basis using an appropriate dict as the argument for na_values.
By default, dropna drops entire rows in which one or more values are missing.
End of explanation
missing_sample.dropna(axis=1)
Explanation: If we want to drop missing values column-wise instead of row-wise, we use axis=1.
End of explanation
missing_sample.fillna(-999)
Explanation: Rather than omitting missing data from an analysis, in some cases it may be suitable to fill the missing value in, either with a default value (such as zero), a sentinel value, or a value that is either imputed or carried forward/backward from similar data points. We can do this programmatically in pandas with the fillna argument.
End of explanation
## Write your answer here
Explanation: Sentinel values are useful in pandas because missing values are treated as floats, so it is impossible to use explicit missing values with integer columns. Using some large (positive or negative) integer as a sentinel value will allow the column to be integer typed.
Exercise: Mean imputation
Fill the missing values in missing_sample with the mean count from the corresponding species across patients.
End of explanation |
3,442 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
How to connect observations to specific models?
In the previous examples there was always a single background model component to describe the residual particle background in the various dataset. This implies that the spatial and spectral shape of the background distribution is assumed to be identical for all observations. This is fine in a simulation, but for a real life situation this assumption will probably not hold.
Start by importing the gammalib, ctools, and cscripts Python modules.
Step1: Simulating the dataset
Let’s start with creating a pointing definition ASCII file for two 30 min pointings near the Crab.
Step2: Inspect the file that you just created. For that purpose let's create a peek() function that will also be used later to display XML files.
Step3: A pointing definition file is an ASCII file in Comma Separated Values (CSV) format that specifies one pointing per row. The file provides the name of the observation, the Right Ascension ra and Declination dec of the pointing, and its duration. Additional optional columns are possible (defining for example the energy range or the Instrument Response Function), but for this simulation the provided information is sufficient.
Now transform the pointing definition file into an observation definition XML file using the csobsdef script.
Step4: Let's peek the resulting observation definition XML file
Step5: The file contains two observations which distinguish by the id attributes 000001 and 000002, which are unique to each observation for a given instrument. The id attribute can therefore be used to uniquely identify a CTA observation.
The value of the id attributes can be controlled by adding specific values to the pointing definition file, but if the values are missing - which is the case in the example - they simply count from 000001 upwards.
Feed now the observation definition XML file into the ctobssim tool to simulate the event data.
Step6: This will produce the two event files sim_events_000001.fits and sim_events_000002.fits on disk. Note that a specific model was used to simulate the data and peeking that model definiton file shows that it contains two different background components with a different power law Prefactor and Index. Both background components also have an id attribute which is used to tie them to the two observations. In other words, Background_000001 will be used for the observation with identifier 000001 and Background_000002 will be used for the observation with identifier 000002.
Step7: Analysing the data
Now run a maximum likelihood fit of the model to the simulated data
Step8: and inspect the model fitting results | Python Code:
import gammalib
import ctools
import cscripts
Explanation: How to connect observations to specific models?
In the previous examples there was always a single background model component to describe the residual particle background in the various dataset. This implies that the spatial and spectral shape of the background distribution is assumed to be identical for all observations. This is fine in a simulation, but for a real life situation this assumption will probably not hold.
Start by importing the gammalib, ctools, and cscripts Python modules.
End of explanation
f = open('pnt.def', 'wb')
f.write('name,ra,dec,duration\n')
f.write('Crab,83.63,21.51,1800.0\n')
f.write('Crab,83.63,22.51,1800.0\n')
f.close()
Explanation: Simulating the dataset
Let’s start with creating a pointing definition ASCII file for two 30 min pointings near the Crab.
End of explanation
def peek(filename):
f = open(gammalib.expand_env(filename), 'r')
for line in f:
print(line.rstrip())
f.close()
peek('pnt.def')
Explanation: Inspect the file that you just created. For that purpose let's create a peek() function that will also be used later to display XML files.
End of explanation
obsdef = cscripts.csobsdef()
obsdef['inpnt'] = 'pnt.def'
obsdef['outobs'] = 'obs.xml'
obsdef['caldb'] = 'prod2'
obsdef['irf'] = 'South_0.5h'
obsdef.execute()
Explanation: A pointing definition file is an ASCII file in Comma Separated Values (CSV) format that specifies one pointing per row. The file provides the name of the observation, the Right Ascension ra and Declination dec of the pointing, and its duration. Additional optional columns are possible (defining for example the energy range or the Instrument Response Function), but for this simulation the provided information is sufficient.
Now transform the pointing definition file into an observation definition XML file using the csobsdef script.
End of explanation
peek('obs.xml')
Explanation: Let's peek the resulting observation definition XML file
End of explanation
obssim = ctools.ctobssim()
obssim['inobs'] = 'obs.xml'
obssim['rad'] = 5.0
obssim['emin'] = 0.1
obssim['emax'] = 100.0
obssim['inmodel'] = '$CTOOLS/share/models/crab_2bkg.xml'
obssim['outevents'] = 'obs_2bkg.xml'
obssim.execute()
Explanation: The file contains two observations which distinguish by the id attributes 000001 and 000002, which are unique to each observation for a given instrument. The id attribute can therefore be used to uniquely identify a CTA observation.
The value of the id attributes can be controlled by adding specific values to the pointing definition file, but if the values are missing - which is the case in the example - they simply count from 000001 upwards.
Feed now the observation definition XML file into the ctobssim tool to simulate the event data.
End of explanation
peek('$CTOOLS/share/models/crab_2bkg.xml')
Explanation: This will produce the two event files sim_events_000001.fits and sim_events_000002.fits on disk. Note that a specific model was used to simulate the data and peeking that model definiton file shows that it contains two different background components with a different power law Prefactor and Index. Both background components also have an id attribute which is used to tie them to the two observations. In other words, Background_000001 will be used for the observation with identifier 000001 and Background_000002 will be used for the observation with identifier 000002.
End of explanation
like = ctools.ctlike()
like['inobs'] = 'obs_2bkg.xml'
like['inmodel'] = '$CTOOLS/share/models/crab_2bkg.xml'
like['outmodel'] = 'crab_results.xml'
like.run()
Explanation: Analysing the data
Now run a maximum likelihood fit of the model to the simulated data
End of explanation
print(like.obs().models())
Explanation: and inspect the model fitting results
End of explanation |
3,443 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Overview
Digital data to be transmitted
Step1: Modulation
Step2: Spectogram shows that we have synthesized positive frequency for True bit and negative for False.
This complex data can be sent to SDR at this point. | Python Code:
samples_per_symbol = 64 # this is so high to make stuff plottable
symbols = [1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0]
data = []
for x in symbols:
data.extend([1 if x else -1] * samples_per_symbol)
plt.plot(data)
plt.title('Data to send')
plt.show()
Explanation: Overview
Digital data to be transmitted
End of explanation
fs = 300e3
deviation = 70e3 # deviation from center frequency
sensitivity = 2 * np.pi * deviation / fs
print(sensitivity)
d_phase = 0
phl = []
for symbol in data:
d_phase += symbol * sensitivity # this is FSK
d_phase = ((d_phase + np.pi) % (2.0 * np.pi)) - np.pi # keep in pi range
phl.append(d_phase * 1j)
sig = np.exp(phl)
# awgn channel
# sig = sig + np.random.normal(scale=np.sqrt(0.1))
Pxx, freqs, bins, im = plt.specgram(sig, Fs=fs, NFFT=64, noverlap=0)
plt.show()
Explanation: Modulation
End of explanation
import inspect
def get_objects_rednode(obj):
source_path = inspect.getsourcefile(type(obj))
source = open(source_path).read()
print(source)
from pyhacores.moving_average.model import MovingAverage
obj = MovingAverage(2)
get_objects_rednode(obj)
Explanation: Spectogram shows that we have synthesized positive frequency for True bit and negative for False.
This complex data can be sent to SDR at this point.
End of explanation |
3,444 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Marked Point Pattern
In addition to the unmarked point pattern, non-binary attributes might be associated with each point, leading to the so-called marked point pattern. The charactertistics of a marked point pattern are
Step1: Create an attribute named quad which has a value for each event.
Step2: Attach the attribute quad to the point pattern
Step3: Explode a marked point pattern into a sequence of individual point patterns. Since the mark quad has 4 unique values, the sequence will be of length 4.
Step4: Plot the 4 individual sequences
Step5: Plot the 4 unmarked point patterns using the same axes for a convenient comparison of locations | Python Code:
from pysal.explore.pointpats import PoissonPointProcess, PoissonClusterPointProcess, Window, poly_from_bbox, PointPattern
import pysal.lib as ps
from pysal.lib.cg import shapely_ext
%matplotlib inline
import matplotlib.pyplot as plt
# open the virginia polygon shapefile
va = ps.io.open(ps.examples.get_path("virginia.shp"))
polys = [shp for shp in va]
# Create the exterior polygons for VA from the union of the county shapes
state = shapely_ext.cascaded_union(polys)
# create window from virginia state boundary
window = Window(state.parts)
window.bbox
window.centroid
samples = PoissonPointProcess(window, 200, 1, conditioning=False, asPP=False)
csr = PointPattern(samples.realizations[0])
cx, cy = window.centroid
cx
cy
west = csr.points.x < cx
south = csr.points.y < cy
east = 1 - west
north = 1 - south
Explanation: Marked Point Pattern
In addition to the unmarked point pattern, non-binary attributes might be associated with each point, leading to the so-called marked point pattern. The charactertistics of a marked point pattern are:
Location pattern of the events are of interest
Stochastic attribute attached to the events is of interest
Unmarked point pattern can be modified to be a marked point pattern using the method add_marks while the method explode could decompose a marked point pattern into a sequence of unmarked point patterns. Both methods belong to the class PointPattern.
End of explanation
quad = 1 * east * north + 2 * west * north + 3 * west * south + 4 * east * south
type(quad)
quad
Explanation: Create an attribute named quad which has a value for each event.
End of explanation
csr.add_marks([quad], mark_names=['quad'])
csr.df
Explanation: Attach the attribute quad to the point pattern
End of explanation
csr_q = csr.explode('quad')
len(csr_q)
csr
csr.summary()
Explanation: Explode a marked point pattern into a sequence of individual point patterns. Since the mark quad has 4 unique values, the sequence will be of length 4.
End of explanation
plt.xlim?
plt.xlim()
for ppn in csr_q:
ppn.plot()
Explanation: Plot the 4 individual sequences
End of explanation
x0, y0, x1, y1 = csr.mbb
ylim = (y0, y1)
xlim = (x0, x1)
for ppn in csr_q:
ppn.plot()
plt.xlim(xlim)
plt.ylim(ylim)
Explanation: Plot the 4 unmarked point patterns using the same axes for a convenient comparison of locations
End of explanation |
3,445 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Homework 2
Step1: If you get an error stating that database "homework2" does not exist, make sure that you followed the instructions above exactly. If necessary, drop the database you created (with, e.g., DROP DATABASE your_database_name) and start again.
In all of the cells below, I've provided the necessary Python scaffolding to perform the query and display the results. All you need to do is write the SQL statements.
As noted in the tutorial, if your SQL statement has a syntax error, you'll need to rollback your connection before you can fix the error and try the query again. As a convenience, I've included the following cell, which performs the rollback process. Run it whenever you hit trouble.
Step2: Problem set 1
Step3: Problem set 2
Step4: Nicely done. Now, in the cell below, fill in the indicated string with a SQL statement that returns all occupations, along with their count, from the uuser table that have more than fifty users listed for that occupation. (I.e., the occupation librarian is listed for 51 users, so it should be included in these results. There are only 12 lawyers, so lawyer should not be included in the result.)
Expected output
Step5: Problem set 3
Step6: Problem set 4
Step7: BONUS | Python Code:
import pg8000
conn = pg8000.connect(user="postgres", password="12345", database="homework2")
Explanation: Homework 2: Working with SQL (Data and Databases 2016)
This homework assignment takes the form of an IPython Notebook. There are a number of exercises below, with notebook cells that need to be completed in order to meet particular criteria. Your job is to fill in the cells as appropriate.
You'll need to download this notebook file to your computer before you can complete the assignment. To do so, follow these steps:
Make sure you're viewing this notebook in Github.
Ctrl+click (or right click) on the "Raw" button in the Github interface, and select "Save Link As..." or your browser's equivalent. Save the file in a convenient location on your own computer.
Rename the notebook file to include your own name somewhere in the filename (e.g., Homework_2_Allison_Parrish.ipynb).
Open the notebook on your computer using your locally installed version of IPython Notebook.
When you've completed the notebook to your satisfaction, e-mail the completed file to the address of the teaching assistant (as discussed in class).
Setting the scene
These problem sets address SQL, with a focus on joins and aggregates.
I've prepared a SQL version of the MovieLens data for you to use in this homework. Download this .psql file here. You'll be importing this data into your own local copy of PostgreSQL.
To import the data, follow these steps:
Launch psql.
At the prompt, type CREATE DATABASE homework2;
Connect to the database you just created by typing \c homework2
Import the .psql file you downloaded earlier by typing \i followed by the path to the .psql file.
After you run the \i command, you should see the following output:
CREATE TABLE
CREATE TABLE
CREATE TABLE
COPY 100000
COPY 1682
COPY 943
The table schemas for the data look like this:
Table "public.udata"
Column | Type | Modifiers
-----------+---------+-----------
user_id | integer |
item_id | integer |
rating | integer |
timestamp | integer |
Table "public.uuser"
Column | Type | Modifiers
------------+-----------------------+-----------
user_id | integer |
age | integer |
gender | character varying(1) |
occupation | character varying(80) |
zip_code | character varying(10) |
Table "public.uitem"
Column | Type | Modifiers
--------------------+------------------------+-----------
movie_id | integer | not null
movie_title | character varying(81) | not null
release_date | date |
video_release_date | character varying(32) |
imdb_url | character varying(134) |
unknown | integer | not null
action | integer | not null
adventure | integer | not null
animation | integer | not null
childrens | integer | not null
comedy | integer | not null
crime | integer | not null
documentary | integer | not null
drama | integer | not null
fantasy | integer | not null
film_noir | integer | not null
horror | integer | not null
musical | integer | not null
mystery | integer | not null
romance | integer | not null
scifi | integer | not null
thriller | integer | not null
war | integer | not null
western | integer | not null
Run the cell below to create a connection object. This should work whether you have pg8000 installed or psycopg2.
End of explanation
conn.rollback()
Explanation: If you get an error stating that database "homework2" does not exist, make sure that you followed the instructions above exactly. If necessary, drop the database you created (with, e.g., DROP DATABASE your_database_name) and start again.
In all of the cells below, I've provided the necessary Python scaffolding to perform the query and display the results. All you need to do is write the SQL statements.
As noted in the tutorial, if your SQL statement has a syntax error, you'll need to rollback your connection before you can fix the error and try the query again. As a convenience, I've included the following cell, which performs the rollback process. Run it whenever you hit trouble.
End of explanation
cursor = conn.cursor()
statement = "select movie_title from uitem where horror = 1 and scifi = 1 order by release_date DESC;"
cursor.execute(statement)
for row in cursor:
print(row[0])
Explanation: Problem set 1: WHERE and ORDER BY
In the cell below, fill in the string assigned to the variable statement with a SQL query that finds all movies that belong to both the science fiction (scifi) and horror genres. Return these movies in reverse order by their release date. (Hint: movies are located in the uitem table. A movie's membership in a genre is indicated by a value of 1 in the uitem table column corresponding to that genre.) Run the cell to execute the query.
Expected output:
Deep Rising (1998)
Alien: Resurrection (1997)
Hellraiser: Bloodline (1996)
Robert A. Heinlein's The Puppet Masters (1994)
Body Snatchers (1993)
Army of Darkness (1993)
Body Snatchers (1993)
Alien 3 (1992)
Heavy Metal (1981)
Alien (1979)
Night of the Living Dead (1968)
Blob, The (1958)
End of explanation
cursor = conn.cursor()
statement = "select count(*) from uitem where musical = 1 or childrens = 1;"
cursor.execute(statement)
for row in cursor:
print(row[0])
Explanation: Problem set 2: Aggregation, GROUP BY and HAVING
In the cell below, fill in the string assigned to the statement variable with a SQL query that returns the number of movies that are either musicals or children's movies (columns musical and childrens respectively). Hint: use the count(*) aggregate.
Expected output: 157
End of explanation
cursor = conn.cursor()
statement = "select occupation, count(occupation) from uuser group by occupation having count(*) > 50;"
cursor.execute(statement)
for row in cursor:
print(row[0], row[1])
Explanation: Nicely done. Now, in the cell below, fill in the indicated string with a SQL statement that returns all occupations, along with their count, from the uuser table that have more than fifty users listed for that occupation. (I.e., the occupation librarian is listed for 51 users, so it should be included in these results. There are only 12 lawyers, so lawyer should not be included in the result.)
Expected output:
administrator 79
programmer 66
librarian 51
student 196
other 105
engineer 67
educator 95
Hint: use GROUP BY and HAVING. (If you're stuck, try writing the query without the HAVING first.)
End of explanation
cursor = conn.cursor()
statement = "select distinct(movie_title) from uitem join udata on uitem.movie_id = udata.item_id where uitem.documentary = 1 and uitem.release_date < '1992-01-01' and udata.rating = 5 order by movie_title;"
cursor.execute(statement)
for row in cursor:
print(row[0])
Explanation: Problem set 3: Joining tables
In the cell below, fill in the indicated string with a query that finds the titles of movies in the Documentary genre released before 1992 that received a rating of 5 from any user. Expected output:
Madonna: Truth or Dare (1991)
Koyaanisqatsi (1983)
Paris Is Burning (1990)
Thin Blue Line, The (1988)
Hints:
JOIN the udata and uitem tables.
Use DISTINCT() to get a list of unique movie titles (no title should be listed more than once).
The SQL expression to include in order to find movies released before 1992 is uitem.release_date < '1992-01-01'.
End of explanation
cursor = conn.cursor()
statement = "select movie_title, avg(rating) from uitem join udata on uitem.movie_id = udata.item_id where horror = 1 group by uitem.movie_title order by avg(udata.rating) limit 10;"
cursor.execute(statement)
for row in cursor:
print(row[0], "%0.2f" % row[1])
Explanation: Problem set 4: Joins and aggregations... together at last
This one's tough, so prepare yourself. Go get a cup of coffee. Stretch a little bit. Deep breath. There you go.
In the cell below, fill in the indicated string with a query that produces a list of the ten lowest rated movies in the Horror genre. For the purposes of this problem, take "lowest rated" to mean "has the lowest average rating." The query should display the titles of the movies, not their ID number. (So you'll have to use a JOIN.)
Expected output:
Amityville 1992: It's About Time (1992) 1.00
Beyond Bedlam (1993) 1.00
Amityville: Dollhouse (1996) 1.00
Amityville: A New Generation (1993) 1.00
Amityville 3-D (1983) 1.17
Castle Freak (1995) 1.25
Amityville Curse, The (1990) 1.25
Children of the Corn: The Gathering (1996) 1.32
Machine, The (1994) 1.50
Body Parts (1991) 1.62
End of explanation
cursor = conn.cursor()
statement = "select movie_title, avg(rating) from uitem join udata on uitem.movie_id = udata.item_id where horror = 1 group by uitem.movie_title having count(udata.rating) > 10 order by avg(udata.rating) limit 10;"
cursor.execute(statement)
for row in cursor:
print(row[0], "%0.2f" % row[1])
Explanation: BONUS: Extend the query above so that it only includes horror movies that have ten or more ratings. Fill in the query as indicated below.
Expected output:
Children of the Corn: The Gathering (1996) 1.32
Body Parts (1991) 1.62
Amityville II: The Possession (1982) 1.64
Jaws 3-D (1983) 1.94
Hellraiser: Bloodline (1996) 2.00
Tales from the Hood (1995) 2.04
Audrey Rose (1977) 2.17
Addiction, The (1995) 2.18
Halloween: The Curse of Michael Myers (1995) 2.20
Phantoms (1998) 2.23
End of explanation |
3,446 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Self-Driving Car Engineer Nanodegree
Deep Learning
Project
Step1: Step 1
Step2: Include an exploratory visualization of the dataset
Visualize the German Traffic Signs Dataset using the pickled file(s). This is open ended, suggestions include
Step10: Step 2
Step11: Model Architecture
Parameters
Step14: Utility Functions
Step15: Placeholders
Step19: Variables
Step21: Model
Step26: Train, Validate and Test the Model
A validation set can be used to assess how well the model is performing. A low accuracy on the training and validation
sets imply underfitting. A high accuracy on the training set but low accuracy on the validation set implies overfitting.
Training
Helper functions
Step27: Training related definitions
Step28: Training session
Step29: Step 3
Step30: Load and Output the Images
Step31: Predict the Sign Type for Each Image
Step32: Analyze Performance
Step33: Output Top 5 Softmax Probabilities For Each Image Found on the Web
For each of the new images, print out the model's softmax probabilities to show the certainty of the model's predictions (limit the output to the top 5 probabilities for each image). tf.nn.top_k could prove helpful here.
The example below demonstrates how tf.nn.top_k can be used to find the top k predictions for each image.
tf.nn.top_k will return the values and indices (class ids) of the top k predictions. So if k=3, for each sign, it'll return the 3 largest probabilities (out of a possible 43) and the correspoding class ids.
Take this numpy array as an example. The values in the array represent predictions. The array contains softmax probabilities for five candidate images with six possible classes. tk.nn.top_k is used to choose the three classes with the highest probability
Step34: First image
Step35: Project Writeup
Once you have completed the code implementation, document your results in a project writeup using this template as a guide. The writeup can be in a markdown or pdf file.
Note | Python Code:
# Load pickled data
import pickle
import numpy as np
import seaborn as sns
training_file = "data/train.p"
validation_file = "data/valid.p"
testing_file = "data/test.p"
with open(training_file, mode='rb') as f:
train = pickle.load(f)
with open(validation_file, mode='rb') as f:
valid = pickle.load(f)
with open(testing_file, mode='rb') as f:
test = pickle.load(f)
X_train, y_train = train['features'], train['labels']
X_valid, y_valid = valid['features'], valid['labels']
X_test, y_test = test['features'], test['labels']
Explanation: Self-Driving Car Engineer Nanodegree
Deep Learning
Project: Build a Traffic Sign Recognition Classifier
In this notebook, a template is provided for you to implement your functionality in stages, which is required to successfully complete this project. If additional code is required that cannot be included in the notebook, be sure that the Python code is successfully imported and included in your submission if necessary.
Note: Once you have completed all of the code implementations, you need to finalize your work by exporting the iPython Notebook as an HTML document. Before exporting the notebook to html, all of the code cells need to have been run so that reviewers can see the final implementation and output. You can then export the notebook by using the menu above and navigating to \n",
"File -> Download as -> HTML (.html). Include the finished document along with this notebook as your submission.
In addition to implementing code, there is a writeup to complete. The writeup should be completed in a separate file, which can be either a markdown file or a pdf document. There is a write up template that can be used to guide the writing process. Completing the code template and writeup template will cover all of the rubric points for this project.
The rubric contains "Stand Out Suggestions" for enhancing the project beyond the minimum requirements. The stand out suggestions are optional. If you decide to pursue the "stand out suggestions", you can include the code in this Ipython notebook and also discuss the results in the writeup file.
Note: Code and Markdown cells can be executed using the Shift + Enter keyboard shortcut. In addition, Markdown cells can be edited by typically double-clicking the cell to enter edit mode.
Please refer to the attached report for a full explanation of the processing pipeline below
Use the notebook only for code checking and commenting.
Step 0: Load The Data
End of explanation
### Replace each question mark with the appropriate value.
### Use python, pandas or numpy methods rather than hard coding the results
n_train = X_train.shape[0]
n_validation = X_valid.shape[0]
n_test = X_test.shape[0]
image_shape = X_test[0,:,:,:].shape
n_classes = np.unique(y_train).shape[0]
print("Number of training examples =", n_train)
print("Number of testing examples =", n_test)
print("Image data shape =", image_shape)
print("Number of classes =", n_classes)
Explanation: Step 1: Dataset Summary & Exploration
The pickled data is a dictionary with 4 key/value pairs:
'features' is a 4D array containing raw pixel data of the traffic sign images, (num examples, width, height, channels).
'labels' is a 1D array containing the label/class id of the traffic sign. The file signnames.csv contains id -> name mappings for each id.
'sizes' is a list containing tuples, (width, height) representing the original width and height the image.
'coords' is a list containing tuples, (x1, y1, x2, y2) representing coordinates of a bounding box around the sign in the image. THESE COORDINATES ASSUME THE ORIGINAL IMAGE. THE PICKLED DATA CONTAINS RESIZED VERSIONS (32 by 32) OF THESE IMAGES
Complete the basic data summary below. Use python, numpy and/or pandas methods to calculate the data summary rather than hard coding the results. For example, the pandas shape method might be useful for calculating some of the summary results.
Provide a Basic Summary of the Data Set Using Python, Numpy and/or Pandas
End of explanation
### Data exploration visualization code goes here.
### Feel free to use as many code cells as needed.
import matplotlib.pyplot as plt
# Visualizations will be shown in the notebook.
%matplotlib inline
plt.figure(1, figsize=(20,10))
plt.subplot(211)
plt.imshow(X_train[100])
plt.subplot(212)
plt.imshow(X_train[1040])
plt.show()
#Here some examples of traffic signs. As we can see they are quite in low resolution. Despite it we can build a deep
#learning model that will be able to accurately recognisee them.
# Here we count how many instances for each classes are present in the training set
counts = [len(y_train[y_train == i]) for i in range(n_classes)]
labels = np.arange(n_classes)
sns.set_style("whitegrid")
plt.figure(figsize=(20,10))
ax = sns.barplot(y=counts, x=labels)
# The plot below shows how unbalanced the dataset is. Some traffic signs are barely represented.
# It will be important that through data augmentation we also take care of this issue.
Explanation: Include an exploratory visualization of the dataset
Visualize the German Traffic Signs Dataset using the pickled file(s). This is open ended, suggestions include: plotting traffic sign images, plotting the count of each sign, etc.
The Matplotlib examples and gallery pages are a great resource for doing visualizations in Python.
NOTE: It's recommended you start with something simple first. If you wish to do more, come back to it after you've completed the rest of the sections. It can be interesting to look at the distribution of classes in the training, validation and test set. Is the distribution the same? Are there more examples of some classes than others?
End of explanation
### Preprocess the data here. It is required to normalize the data. Other preprocessing steps could include
### converting to grayscale, etc.
### Feel free to use as many code cells as needed.
import cv2
def to_greyscale(data, contrast_normalization=False):
This function applies greyscale transformation and calls global contrast normalization on
each image if the parameter contrast_normalization is set to True
data_transformed = []
for i in range(data.shape[0]):
image = cv2.cvtColor(data[i], cv2.COLOR_RGB2GRAY)
if contrast_normalization:
image = GCN(image)
data_transformed.append(image)
return np.array(data_transformed).reshape(data.shape[:-1] + (1,)).astype(np.float32)
def GCN(image):
It applies global contrast normalization on the input image.
mean = np.mean(image)
std = np.std(image, ddof=1)
return (image-mean)/std
#Here we transform the data sets according to greyscale and GCN preprocessing
X_train = to_greyscale(X_train, contrast_normalization=True)
X_valid = to_greyscale(X_valid, contrast_normalization=True)
X_test = to_greyscale(X_test, contrast_normalization=True)
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
def apply_rescale(image, max_scale_factor = 0.05):
Rescales the image around the center. The scaling factor is chosen randomly.
:param image: The image to rescale
:param max_scale_factor: The maximum value of the rescaling factor allowed
:return: The rescaled image
s_x = 1.0 + np.random.uniform(-max_scale_factor, max_scale_factor)
s_y = 1.0 + np.random.uniform(-max_scale_factor, max_scale_factor)
M = np.array([[s_x, 0.0, 0.0], [0.0, s_y, 0.0]], dtype = np.float32)
rows, cols, ch = image.shape
return cv2.warpAffine(image, M, (cols, rows))
def apply_rotation(image, max_angle = 10):
Apply a rotation around the center to the input image. Used for data augmentation
:param image: The image to rotate
:param angle: The angle of rotation.
:return: The rotated image
rows, cols = image.shape[:-1]
angle = np.random.uniform(-max_angle, max_angle)
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), angle, 1)
return cv2.warpAffine(image, M, (cols, rows))
def apply_translation(image, max_pixel_shift = 3):
Applies a translation to the image either along the x or y axis.
:param image: The image to translate
:param max_pixel_shift: The maximum absolute value of pixel shift-
:return: The translated image
rows, cols = image.shape[:-1]
shift = np.random.randint(-max_pixel_shift, max_pixel_shift)
if np.random.randint(0, 1) == 0:
M = np.float32([[1, 0, shift], [0, 1, 0]])
else:
M = np.float32([[1, 0, 0], [0, 1, shift]])
return cv2.warpAffine(image, M, (cols, rows))
def apply_transformation(image):
Applies randomly one of the three affine transformations to the input.
t = np.random.randint(0, 2)
if t == 0:
return apply_translation(image)
elif t == 1:
return apply_rotation(image)
else:
return apply_rescale(image)
def data_augmentation(X, y, max_instances=10000, seed=0):
This function is used to augment the datasets. It generates max_instances for each class by applying
rotations, translations or rescaling to the images. The random generator seed can be also set.
np.random.seed(seed)
X_augmented = []
y_augmented = []
for i in range(n_classes):
n_samples = len(y[y==i])
X_sub = X[y==i]
if n_samples > max_instances:
for i in range(max_instances):
X_augmented.append(X_sub[i])
y_augmented.append(i)
else:
k = 0
while k < max_instances:
image = X_sub[k % n_samples]
X_augmented.append(apply_transformation(image))
y_augmented.append(i)
k += 1
return np.array(X_augmented), np.array(y_augmented)
#Data augmentation is only applied to the training set
X_train, y_train = data_augmentation(X_train, y_train)
X_train = X_train.reshape(X_train.shape + (1,) )
#Here we apply one-hot encoding to the labels for training, validation and test set
label_binarizer = LabelBinarizer()
label_binarizer.fit(range(max(y_train)+1))
y_train = label_binarizer.transform(y_train)
y_valid = label_binarizer.transform(y_valid)
y_test = label_binarizer.transform(y_test)
X_train, _, y_train, _ = train_test_split(X_train, y_train, test_size=0.00001, random_state=42)
plt.imshow(X_train[1000,:,:,0])
plt.savefig("data/report_images/augmented1.jpg")
plt.imshow(X_train[100000,:,:,0])
plt.savefig("data/report_images/augmented2.jpg")
plt.imshow(X_train[400000,:,:,0])
plt.savefig("data/report_images/augmented3.jpg")
Explanation: Step 2: Design and Test a Model Architecture
Design and implement a deep learning model that learns to recognize traffic signs. Train and test your model on the German Traffic Sign Dataset.
The LeNet-5 implementation shown in the classroom at the end of the CNN lesson is a solid starting point. You'll have to change the number of classes and possibly the preprocessing, but aside from that it's plug and play!
With the LeNet-5 solution from the lecture, you should expect a validation set accuracy of about 0.89. To meet specifications, the validation set accuracy will need to be at least 0.93. It is possible to get an even higher accuracy, but 0.93 is the minimum for a successful project submission.
There are various aspects to consider when thinking about this problem:
Neural network architecture (is the network over or underfitting?)
Play around preprocessing techniques (normalization, rgb to grayscale, etc)
Number of examples per label (some have more than others).
Generate fake data.
Here is an example of a published baseline model on this problem. It's not required to be familiar with the approach used in the paper but, it's good practice to try to read papers like these.
Pre-process the Data Set (normalization, grayscale, etc.)
Minimally, the image data should be normalized so that the data has mean zero and equal variance. For image data, (pixel - 128)/ 128 is a quick way to approximately normalize the data and can be used in this project.
Other pre-processing steps are optional. You can try different techniques to see if it improves performance.
Use the code cell (or multiple code cells, if necessary) to implement the first step of your project.
End of explanation
# Input dimension of the images
img_rows, img_cols, nb_channels = (32, 32, 1)
# Number of classes in the dataset
nb_classes = 43
# Network structure
structure = [{"type": "conv", "params": {"patch_x": 5, "patch_y": 5, "depth": 16, "channels": 1, "stride" : 1}},
{"type": "pool", "params": {"side": 2, "stride": 2, "pad": "SAME"}},
{"type": "conv", "params": {"patch_x": 5, "patch_y": 5, "depth": 32, "channels": 16, "stride" : 1}},
{"type": "pool", "params": {"side": 2, "stride": 2, "pad": "SAME"}},
{"type": "conv", "params": {"patch_x": 5, "patch_y": 5, "depth": 64, "channels": 32, "stride" : 1}},
{"type": "pool", "params": {"side": 2, "stride": 2, "pad": "SAME"}},
{"type": "dense", "params": {"n_input": 1024, "n_output": 512}}]
dropout = 0.5
# Initializer variable parameters
std_variables = 0.1
constant_bias = 0.1
# Training
optim = {"type" : "Adam"}
batch_size = 128
Explanation: Model Architecture
Parameters: Here we define all the parameters and hyperparameters of the Convolutional Neural Network
End of explanation
import tensorflow as tf
def weight_variable(shape, std=0.1, name=None):
Initializes variables according to a normal distribution with zero mean and standard
deviation stddev.
:param shape: Provides the shape of the container of the variables
:param std: Defines the standard deviation of the normal distribution
initial = tf.truncated_normal(shape, stddev=std, name=name)
return tf.Variable(initial)
def bias_variable(shape, value=0.1, name=None):
Initialiezes variables all equal to a constant.
:param shape: Provides the shape of the container of the variables
:param value: Defines the value of the constant to which all the variables are initialized.
initial = tf.constant(value, shape=shape, name=name)
return tf.Variable(initial)
Explanation: Utility Functions
End of explanation
# These placeholders are used to feed tf variables when needed. The first hold a batch of input
# images, the second holds a batch of one-hot encoded labels
x_holder = tf.placeholder(tf.float32, shape=[None, img_rows, img_cols, nb_channels], name="x")
y_holder = tf.placeholder(tf.float32, shape=[None, nb_classes], name="labels")
Explanation: Placeholders
End of explanation
def conv_layer(X, w, b, params ,local_response=True):
Passes the input X through a convolutional layer given weights w, bias b and hyperparameters params. It can also
perform a local response normalization if set to True. Returns the operation output
conv = tf.nn.conv2d(X, w, strides=[1, params["stride"], params["stride"], 1], padding='SAME') + b
if local_response:
return tf.nn.local_response_normalization(tf.nn.relu(conv))
else:
return tf.nn.relu(conv)
def dense_layer(X, w, b, params, dropout=None):
Passes the input X through a fully connected layer with relu given weights w, bias b and hyperparameters params.
Returns the operation output
shape = X.get_shape()
return tf.nn.relu(tf.matmul(X, w) + b)
def pool_layer(X, params):
Passes the input X through a max pool layer given weights w, bias b and hyperparameters params.
Returns the operation output
return tf.nn.max_pool(X, ksize=[1, params["side"], params["side"], 1],
strides=[1, params["stride"], params["stride"], 1],
padding='SAME')
#Here all the relevant variables, weights and biases for all layers, are defined. I also
#employ syntax used in the tensorboard API for debugging purposes
with tf.name_scope("conv1"):
params = structure[0]["params"]
W_conv_1 = weight_variable([params["patch_x"], params["patch_y"], params["channels"], params["depth"]], name="W")
b_conv_1 = bias_variable([params["depth"]], name="b")
tf.summary.histogram("weights", W_conv_1)
tf.summary.histogram("biases", b_conv_1)
with tf.name_scope("conv2"):
params = structure[2]["params"]
W_conv_2 = weight_variable([params["patch_x"], params["patch_y"], params["channels"], params["depth"]], name="W")
b_conv_2 = bias_variable([params["depth"]], name="b")
tf.summary.histogram("weights", W_conv_2)
tf.summary.histogram("biases", b_conv_2)
with tf.name_scope("conv3"):
params = structure[4]["params"]
W_conv_3 = weight_variable([params["patch_x"], params["patch_y"], params["channels"], params["depth"]], name="W")
b_conv_3 = bias_variable([params["depth"]], name="b")
tf.summary.histogram("weights", W_conv_3)
tf.summary.histogram("biases", b_conv_3)
with tf.name_scope("dense1"):
params = structure[6]["params"]
W_dense_1 = weight_variable([params["n_input"], params["n_output"]], name="W")
b_dense_1 = bias_variable([params["n_output"]], name="b")
tf.summary.histogram("weights", W_dense_1)
tf.summary.histogram("biases", b_dense_1)
with tf.name_scope("final_layer"):
W_final = weight_variable([structure[6]["params"]["n_output"], nb_classes], name="W")
b_final = bias_variable([nb_classes], name="b")
Explanation: Variables
End of explanation
# Here we define the full feedforward model. Dropout is also inserted.
def _model(X_image, dropout=1.0):
It feed forwards the input X_image into the full network structure.
There are 3 convolution+relu+Maxpool layers, then a flattening
layer, a fully connected layer, a dropout layer and outputs the logits.
data = X_image
conv1 = conv_layer(data, W_conv_1, b_conv_1, structure[0]["params"])
pool1 = pool_layer(conv1, structure[1]["params"])
conv2 = conv_layer(pool1, W_conv_2, b_conv_2, structure[2]["params"])
pool2 = pool_layer(conv2, structure[3]["params"])
conv3 = conv_layer(pool2, W_conv_3, b_conv_3, structure[4]["params"])
pool3 = pool_layer(conv3, structure[5]["params"])
shape = pool3.get_shape()
reshaped = tf.reshape(pool3, [-1, int(shape[1]*shape[2]*shape[3])])
dense1 = dense_layer(reshaped, W_dense_1, b_dense_1, structure[6]["params"])
dropped = tf.nn.dropout(dense1, dropout)
return tf.matmul(dropped, W_final) + b_final
Explanation: Model
End of explanation
def _optimizer_type(optimizer, loss):
Chooses the optimizer.
if optimizer["type"] == "Adagrad":
learning_rate = tf.train.exponential_decay(0.05, tf.Variable(0), 10000, 0.95)
return tf.train.AdagradOptimizer(learning_rate).minimize(loss, global_step=tf.Variable(0))
elif optimizer["type"] == "Adam":
return tf.train.AdamOptimizer(0.001).minimize(loss)
def next_batch(X, y, length, batch_init):
Utility function to feed new batches for the training phase
if (batch_init + 1) * length <= len(y):
init = batch_init * length
fin = (batch_init + 1) * length
batch_init += 1
return X[init: fin], y[init: fin], batch_init
else:
init = batch_init * length
batch_init = 0
return X[init:], y[init:], batch_init
def prepare_dict(batch):
Helper function for feeding the a dictionary into the placeholders.
return {x_holder: batch[0].reshape(-1, img_rows, img_cols, nb_channels),
y_holder : batch[1]}
def _accuracy(predictions, actual):
The accuracy function
return 100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(actual, 1))/predictions.shape[0]
Explanation: Train, Validate and Test the Model
A validation set can be used to assess how well the model is performing. A low accuracy on the training and validation
sets imply underfitting. A high accuracy on the training set but low accuracy on the validation set implies overfitting.
Training
Helper functions
End of explanation
#Here we define the cost function, the optimizer and the prediction container which is used to
#evaluate the prediction given an input.
with tf.name_scope('cross_entropy'):
logits = _model(x_holder, dropout)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y_holder))
tf.summary.scalar('cross_entropy', loss)
with tf.name_scope("train"):
optimizer = _optimizer_type(optim, loss)
prediction = tf.nn.softmax(_model(x_holder, 1.0))
Explanation: Training related definitions
End of explanation
#Here the training session is performed. The trained model is also saved for future reference.
import os
nb_epochs = 10
logging_info = 500
with tf.Session() as sess:
train_writer = tf.summary.FileWriter("./logs/model_adam_local_response_10epoches_one_fc", sess.graph)
merged = tf.summary.merge_all()
tf.initialize_all_variables().run()
batch_epochs = int(X_train.shape[0]/batch_size)*nb_epochs
batch_init = 0
for step in range(batch_epochs):
batch = next_batch(X_train, y_train, batch_size, batch_init)
batch_init = batch[2]
_ = sess.run(optimizer, feed_dict=prepare_dict(batch))
if step % logging_info == 0:
l, results, summary = sess.run([loss, prediction, merged], feed_dict=prepare_dict(batch))
train_writer.add_summary(summary, step)
print("Minibatch loss value at step {}: {:.2f}".format(step+1, l))
minibatch_accuracy = _accuracy(results, batch[1])
print("Minibatch accuracy: {:.1f}%".format(minibatch_accuracy))
valid_results = sess.run(prediction, feed_dict={x_holder : X_valid})
valid_accuracy = _accuracy(valid_results, y_valid)
print("Validation set accuracy: {:.1f}%".format(valid_accuracy))
saver = tf.train.Saver()
save_path = os.path.join("models/", 'model_adam_local_response_20epoches_one_fc.ckpt')
saver.save(sess, save_path);
Explanation: Training session
End of explanation
#I load the saved model to evaluate accuracy on the validation and test set.
with tf.Session() as sess:
saver = tf.train.Saver()
saver.restore(sess, os.path.join("models/", 'model_adam_local_response_20epoches_one_fc.ckpt'))
test_res = sess.run(prediction, feed_dict={x_holder : X_test})
valid_res = sess.run(prediction, feed_dict={x_holder : X_valid})
valid_accuracy = _accuracy(valid_res, y_valid)
test_accuracy = _accuracy(test_res, y_test)
print("Validation set accuracy: {:.1f}% and Test set accuracy : {:.1f}%".format(valid_accuracy, test_accuracy))
Explanation: Step 3: Test a Model on New Images
To give yourself more insight into how your model is working, download at least five pictures of German traffic signs from the web and use your model to predict the traffic sign type.
You may find signnames.csv useful as it contains mappings from the class id (integer) to the actual sign name.
Load saved model
End of explanation
### Load the images and plot them here.
### Feel free to use as many code cells as needed.
#Here I load the 5 images and preprocess them before inputing into the network
import matplotlib.image as mpimg
img1 = mpimg.imread('./data/sign1.jpg')
img1 = img1[40:310,50:400]
img1 = cv2.resize(img1,(32,32), interpolation = cv2.INTER_CUBIC)
img1 = cv2.cvtColor(img1, cv2.COLOR_RGB2GRAY)
img1 = GCN(img1)
plt.imshow(img1);
plt.savefig("./data/processed1.jpg")
plt.show()
img2 = mpimg.imread('./data/sign2.jpg')
img2 = img2[25:150,60:190]
img2 = cv2.resize(img2,(32,32), interpolation = cv2.INTER_CUBIC)
img2 = cv2.cvtColor(img2, cv2.COLOR_RGB2GRAY)
img2 = GCN(img2)
plt.imshow(img2);
plt.savefig("./data/processed2.jpg")
plt.show()
img3 = mpimg.imread('./data/sign3.jpg')
img3 = img3[:180,30:230]
img3 = cv2.resize(img3,(32,32), interpolation = cv2.INTER_CUBIC)
img3 = cv2.cvtColor(img3, cv2.COLOR_RGB2GRAY)
img3 = GCN(img3)
plt.imshow(img3);
plt.savefig("./data/processed3.jpg")
plt.show()
img4 = mpimg.imread('./data/sign4.jpg')
img4 = img4[:185,:]
img4 = cv2.resize(img4,(32,32), interpolation = cv2.INTER_CUBIC)
img4 = cv2.cvtColor(img4, cv2.COLOR_RGB2GRAY)
img4 = GCN(img4)
plt.imshow(img4);
plt.savefig("./data/processed4.jpg")
plt.show()
img5 = mpimg.imread('./data/sign5.jpg')
img5 = img5[:190,:]
img5 = cv2.resize(img5,(32,32), interpolation = cv2.INTER_CUBIC)
img5 = cv2.cvtColor(img5, cv2.COLOR_RGB2GRAY)
img5 = GCN(img5)
plt.imshow(img5);
plt.savefig("./data/processed5.jpg")
plt.show()
#This is the array containing the 5 images in the form ready to be processed by the network
images = np.array([img1, img2, img3, img4, img5]).reshape((-1, 32, 32, 1))
Explanation: Load and Output the Images
End of explanation
### Run the predictions here and use the model to output the prediction for each image.
### Make sure to pre-process the images with the same pre-processing pipeline used earlier.
### Feel free to use as many code cells as needed.
#Here I predict the classes for the 5 images
with tf.Session() as sess:
saver = tf.train.Saver()
saver.restore(sess, os.path.join("models/", "model_adam_local_response_20epoches_one_fc.ckpt"))
image_res = sess.run(prediction, feed_dict={x_holder : images})
np.argmax(image_res[0]),np.argmax(image_res[1]),np.argmax(image_res[2]),np.argmax(image_res[3]),np.argmax(image_res[4])
Explanation: Predict the Sign Type for Each Image
End of explanation
### Calculate the accuracy for these 5 new images.
### For example, if the model predicted 1 out of 5 signs correctly, it's 20% accurate on these new images.
print ("Performance on 5 images: {:.1f}%".format(100))
#All images have been correctly classified
Explanation: Analyze Performance
End of explanation
### Print out the top five softmax probabilities for the predictions on the German traffic sign images found on the web.
### Feel free to use as many code cells as needed.
# Utility function for bar plots
def bar_plot_softmax(n, path, cutoff=5):
ind = np.sort(np.argpartition(image_res[n], -cutoff)[-cutoff:])
sns.set_style("whitegrid")
plt.figure(figsize=(7,4))
ax = sns.barplot(y=image_res[n][ind], x=ind)
plt.savefig(path)
plt.show()
Explanation: Output Top 5 Softmax Probabilities For Each Image Found on the Web
For each of the new images, print out the model's softmax probabilities to show the certainty of the model's predictions (limit the output to the top 5 probabilities for each image). tf.nn.top_k could prove helpful here.
The example below demonstrates how tf.nn.top_k can be used to find the top k predictions for each image.
tf.nn.top_k will return the values and indices (class ids) of the top k predictions. So if k=3, for each sign, it'll return the 3 largest probabilities (out of a possible 43) and the correspoding class ids.
Take this numpy array as an example. The values in the array represent predictions. The array contains softmax probabilities for five candidate images with six possible classes. tk.nn.top_k is used to choose the three classes with the highest probability:
```
(5, 6) array
a = np.array([[ 0.24879643, 0.07032244, 0.12641572, 0.34763842, 0.07893497,
0.12789202],
[ 0.28086119, 0.27569815, 0.08594638, 0.0178669 , 0.18063401,
0.15899337],
[ 0.26076848, 0.23664738, 0.08020603, 0.07001922, 0.1134371 ,
0.23892179],
[ 0.11943333, 0.29198961, 0.02605103, 0.26234032, 0.1351348 ,
0.16505091],
[ 0.09561176, 0.34396535, 0.0643941 , 0.16240774, 0.24206137,
0.09155967]])
```
Running it through sess.run(tf.nn.top_k(tf.constant(a), k=3)) produces:
TopKV2(values=array([[ 0.34763842, 0.24879643, 0.12789202],
[ 0.28086119, 0.27569815, 0.18063401],
[ 0.26076848, 0.23892179, 0.23664738],
[ 0.29198961, 0.26234032, 0.16505091],
[ 0.34396535, 0.24206137, 0.16240774]]), indices=array([[3, 0, 5],
[0, 1, 4],
[0, 5, 1],
[1, 3, 5],
[1, 4, 3]], dtype=int32))
Looking just at the first row we get [ 0.34763842, 0.24879643, 0.12789202], you can confirm these are the 3 largest probabilities in a. You'll also notice [3, 0, 5] are the corresponding indices.
End of explanation
bar_plot_softmax(0, "data/softmax1.jpg")
bar_plot_softmax(1, "data/softmax2.jpg")
bar_plot_softmax(2, "data/softmax3.jpg")
bar_plot_softmax(3, "data/softmax4.jpg")
bar_plot_softmax(4, "data/softmax5.jpg")
Explanation: First image
End of explanation
def _conv_layer_1_output(X_image, pool=True):
data = X_image
conv1 = conv_layer(data, W_conv_1, b_conv_1, structure[0]["params"])
if pool:
return pool_layer(conv1, structure[1]["params"])
else:
return conv1
def _conv_layer_2_output(X_image, pool=True):
data = X_image
conv1 = conv_layer(data, W_conv_1, b_conv_1, structure[0]["params"])
pool1 = pool_layer(conv1, structure[1]["params"])
conv2 = conv_layer(pool1, W_conv_2, b_conv_2, structure[2]["params"])
if pool:
return pool_layer(conv2, structure[3]["params"])
else:
return conv2
def _conv_layer_3_output(X_image, pool=True):
data = X_image
conv1 = conv_layer(data, W_conv_1, b_conv_1, structure[0]["params"])
pool1 = pool_layer(conv1, structure[1]["params"])
conv2 = conv_layer(pool1, W_conv_2, b_conv_2, structure[2]["params"])
pool2 = pool_layer(conv2, structure[3]["params"])
conv3 = conv_layer(pool2, W_conv_3, b_conv_3, structure[4]["params"])
if pool:
return pool_layer(conv3, structure[5]["params"])
else:
return conv3
with tf.Session() as sess:
saver = tf.train.Saver()
saver.restore(sess, os.path.join("models/", "model_adam_local_response_20epoches_one_fc.ckpt"))
first_feature_maps = _conv_layer_1_output(x_holder, False)
second_feature_maps = _conv_layer_2_output(x_holder,False)
third_feature_maps = _conv_layer_3_output(x_holder,False)
first, second, third = sess.run([first_feature_maps, second_feature_maps, third_feature_maps],
feed_dict={x_holder: img1.reshape((1,32,32,1))})
plt.imshow(second[0,:,:,5]);
### Visualize your network's feature maps here.
### Feel free to use as many code cells as needed.
# image_input: the test image being fed into the network to produce the feature maps
# tf_activation: should be a tf variable name used during your training procedure that represents the calculated state of a specific weight layer
# activation_min/max: can be used to view the activation contrast in more detail, by default matplot sets min and max to the actual min and max values of the output
# plt_num: used to plot out multiple different weight feature map sets on the same block, just extend the plt number for each new feature map entry
def outputFeatureMap(image_input, tf_activation, activation_min=-1, activation_max=-1 ,plt_num=1):
# Here make sure to preprocess your image_input in a way your network expects
# with size, normalization, ect if needed
# image_input =
# Note: x should be the same name as your network's tensorflow data placeholder variable
# If you get an error tf_activation is not defined it may be having trouble accessing the variable from inside a function
activation = tf_activation.eval(session=sess,feed_dict={x : image_input})
featuremaps = activation.shape[3]
plt.figure(plt_num, figsize=(15,15))
for featuremap in range(featuremaps):
plt.subplot(6,8, featuremap+1) # sets the number of feature maps to show on each row and column
plt.title('FeatureMap ' + str(featuremap)) # displays the feature map number
if activation_min != -1 & activation_max != -1:
plt.imshow(activation[0,:,:, featuremap], interpolation="nearest", vmin =activation_min, vmax=activation_max, cmap="gray")
elif activation_max != -1:
plt.imshow(activation[0,:,:, featuremap], interpolation="nearest", vmax=activation_max, cmap="gray")
elif activation_min !=-1:
plt.imshow(activation[0,:,:, featuremap], interpolation="nearest", vmin=activation_min, cmap="gray")
else:
plt.imshow(activation[0,:,:, featuremap], interpolation="nearest", cmap="gray")
Explanation: Project Writeup
Once you have completed the code implementation, document your results in a project writeup using this template as a guide. The writeup can be in a markdown or pdf file.
Note: Once you have completed all of the code implementations and successfully answered each question above, you may finalize your work by exporting the iPython Notebook as an HTML document. You can do this by using the menu above and navigating to \n",
"File -> Download as -> HTML (.html). Include the finished document along with this notebook as your submission.
The writeup can be found in the attached pdf report
Step 4 (Optional): Visualize the Neural Network's State with Test Images
This Section is not required to complete but acts as an additional excersise for understaning the output of a neural network's weights. While neural networks can be a great learning device they are often referred to as a black box. We can understand what the weights of a neural network look like better by plotting their feature maps. After successfully training your neural network you can see what it's feature maps look like by plotting the output of the network's weight layers in response to a test stimuli image. From these plotted feature maps, it's possible to see what characteristics of an image the network finds interesting. For a sign, maybe the inner network feature maps react with high activation to the sign's boundary outline or to the contrast in the sign's painted symbol.
Provided for you below is the function code that allows you to get the visualization output of any tensorflow weight layer you want. The inputs to the function should be a stimuli image, one used during training or a new one you provided, and then the tensorflow variable name that represents the layer's state during the training process, for instance if you wanted to see what the LeNet lab's feature maps looked like for it's second convolutional layer you could enter conv2 as the tf_activation variable.
For an example of what feature map outputs look like, check out NVIDIA's results in their paper End-to-End Deep Learning for Self-Driving Cars in the section Visualization of internal CNN State. NVIDIA was able to show that their network's inner weights had high activations to road boundary lines by comparing feature maps from an image with a clear path to one without. Try experimenting with a similar test to show that your trained network's weights are looking for interesting features, whether it's looking at differences in feature maps from images with or without a sign, or even what feature maps look like in a trained network vs a completely untrained one on the same sign image.
<figure>
<img src="visualize_cnn.png" width="380" alt="Combined Image" />
<figcaption>
<p></p>
<p style="text-align: center;"> Your output should look something like this (above)</p>
</figcaption>
</figure>
<p></p>
End of explanation |
3,447 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
ATM 623
Step1: Homework questions
Step2: The temperature data is called air. Take a look at the details | Python Code:
# Ensure compatibility with Python 2 and 3
from __future__ import print_function, division
Explanation: ATM 623: Climate Modeling
Brian E. J. Rose, University at Albany
Climate sensivity and the energy budget in CESM
Warning: content out of date and not maintained
You really should be looking at The Climate Laboratory book by Brian Rose, where all the same content (and more!) is kept up to date.
Here you are likely to find broken links and broken code.
In this assignment you will investigate how the CESM slab ocean model responds to a doubling of atmospheric CO2.
Refer to Assignment 2 for detailed instructions on how to access the CESM output.
Your assigment
Answer all questions listed in this notebook.
As before, write up your answers (including text, code and figures) in a new IPython notebook. Try to make sure that your notebook runs cleanly from start to finish, and explicitly imports every package that it uses.
Save your notebook as [your last name].ipynb, e.g. my notebook should be called Rose.ipynb.
Submit your answers by email before class on Tuesday February 21.
End of explanation
import xarray as xr
url = "http://www.esrl.noaa.gov/psd/thredds/dodsC/Datasets/ncep.reanalysis.derived/surface_gauss/air.2m.mon.1981-2010.ltm.nc"
ncep_air2m = xr.open_dataset(url, decode_times=False)
## The NOAA ESRL server is shutdown! January 2019
#url = 'http://apdrc.soest.hawaii.edu:80/dods/public_data/Reanalysis_Data/NCEP/NCEP/clima/'
#ncep_air2m = xr.open_dataset(url + 'surface_gauss/air')
print( ncep_air2m)
Explanation: Homework questions: part A
Here we investigate differences between the control simulation and the 2xCO2 simulation (after it has reached its new, warmer equilibrium).
The two model output files you need are the control run:
som_1850_f19.cam.h0.clim.nc
and the doubled CO2 run:
som_1850_2xCO2.cam.h0.clim.nc
Calculate Equilibrium Climate Sensitivity (ECS) for the CESM slab ocean model.
Calculate the net TOA energy flux in the control run and in the equilibrated 2xCO2 run (time and global averages). Are they both close to zero?
What is the change in ASR and the change in OLR after doubling CO2?
What are the clear-sky and cloudy-sky components of those changes?
Make well-labeled maps of the change in the annual mean of these five quantities:
Surface temperature
ASR (total)
ASR (clear sky)
ASR (cloudy sky)
OLR (total)
OLR (clear sky)
OLR (cloud sky)
Comment on what you found in your maps.
Which regions warm more than others?
Are there any discernible spatial patterns in ASR and OLR changes?
What about the clear and cloudy sky components?
Comment on anything you find striking, interesting, or unexpected in these results.
Homework questions: part B
Here we investigate the transient adjustment to equilibrium.
For this, we will use the file
som_1850_2xCO2.cam.h0.global.nc
This file contains a monthly timeseries of the CESM model output from the 2xCO2 model run, which was initialized from the control run. Every variable in this file has already been averaged globally. We can use the timeseries to look at the adjustment of the global average temperature and energy budget to the new equilibrium.
Make a well-labeled graph of the timeseries of global mean surface temperature.
You will find that there is a well-defined annual cycle in this temperature. Offer a reasonable hypothesis to explain why such a cycle exists in the simulation.
Implement some kind of running average filter to smooth out the data. (There are many ways to do this... do whatever makes sense to you, but make sure your code is self-explanatory).
Make another graph of the smooth timeseries. Does it look anything like the exponential relaxation curves we found in the zero-dimensional EBM?
In another graph, plot smoothed verions of the timeseries of ASR and OLR.
Comment on anything interesting you learned from these figures.
Verifying the annual cycle in global mean surface temperature against observations
Here we still study the annual cycle in global mean surface temperature and verify it against observations. For observations, we will use the NCEP Reanalysis data.
Reanalysis data is really a blend of observations and output from numerical weather prediction models. It represents our “best guess” at conditions over the whole globe, including regions where observations are very sparse.
The necessary data are all served up over the internet. We will look at monthly climatologies averaged over the 30 year period 1981 - 2010.
The data catalog is here, please feel free to browse: http://www.esrl.noaa.gov/psd/thredds/dodsC/Datasets/ncep.reanalysis.derived/catalog.html
Surface air temperature is contained in a file called air.2m.mon.1981-2010.ltm.nc, which is found in the directory surface_gauss.
Here's a link directly to the catalog page for this data file:
http://www.esrl.noaa.gov/psd/thredds/dodsC/Datasets/ncep.reanalysis.derived/surface_gauss/catalog.html?dataset=Datasets/ncep.reanalysis.derived/surface_gauss/air.2m.mon.1981-2010.ltm.nc
Now click on the OPeNDAP link. A page opens up with lots of information about the contents of the file. The Data URL is what we need to read the data into our Python session. For example, this code opens the file and displays a list of the variables it contains:
End of explanation
print( ncep_air2m.air)
Explanation: The temperature data is called air. Take a look at the details:
End of explanation |
3,448 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Re-exploratory Analysis
We wish to study the data from a different angle, since the histogram doesn't give us a lot use full information. We first extract 12 Haralick features and other informations from each raw brain image data using matlab, features are computed over a certain region. See the information about roi features extraction.
Note
Step1: Distribution of 12 features
Let's look into the data first.
Plot and compare the distribution of 12 features on same region.
Step2: ROI 3D position plot | Python Code:
FEATURES_PATH = '../code/data/roi_features/features.csv' # use your own path
import numpy as np
import matplotlib
matplotlib.use('AGG') # avoid some error in matplotlib, delete this line if the following doesn't work
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import jgraph as ig
%matplotlib inline
# DATA description (column description)
# 0. class label [0=cocaine | 1=control | 2=fear]
# 1. brain number
# 2. roi number
# 3. roi position X
# 4. roi position Y
# 5. roi position Z
# 6. roi mean
# 7. roi std
# 8. Haralick feature - Energy
# 9. Haralick feature - Entropy
# 10. Haralick feature - Correlation
# 11. Haralick feature - Contrast
# 12. Haralick feature - Variance
# 13. Haralick feature - SumMean
# 14. Haralick feature - Inertia
# 15. Haralick feature - Cluster Shade
# 16. Haralick feature - Cluster tendency
# 17. Haralick feature - Homogeneity
# 18. Haralick feature - MaxProbability
# 19. Haralick feature - Inverse Variance
fields = ['label','nbrain','nroi','roix','roiy','roiy','mean','std','energy','entropy','correlation','contrast','variance',
'summean','inertia','cluster shade','cluster tendency','homogeneity','maxProbability','inverse variance']
data = np.genfromtxt(FEATURES_PATH, delimiter=",", dtype=np.float32)# the features data have been pre-processed and merged
brain_nums = np.unique(data[:,1])
roi_nums = np.unique(data[:,2])
# preview - print brain numbers
print brain_nums
# preview - print roi numbers
print roi_nums
Explanation: Re-exploratory Analysis
We wish to study the data from a different angle, since the histogram doesn't give us a lot use full information. We first extract 12 Haralick features and other informations from each raw brain image data using matlab, features are computed over a certain region. See the information about roi features extraction.
Note: The matlab program takes each image volume data and annotation data into memory. Though optimized, the program still supposed to be run on a machine or server with sufficent memory and computation resources.
Setup
Setup environment and read data
End of explanation
fig, ax = plt.subplots(5,3,sharex=True,sharey=False,figsize=(16,14))
plt.subplots_adjust(hspace = 0.35, wspace = 0.30)
axesList = []
for axes in ax:
axesList.extend(axes)
for brain_n in brain_nums:
tmp = data[data[:,1]==brain_n,:]
tmp = tmp[np.argsort(tmp[:, 2]),:]
if tmp[0,0] == 0:
color = 'r' # cocaine
elif tmp[0,0] == 1:
color = 'g' # control
elif tmp[0,0] == 2:
color = 'b' # fear
for i, ax in enumerate(axesList[:-1]):
ax.plot(range(len(tmp[:,2])),tmp[:,6+i],color,alpha=0.5,marker='.')
ax.set_title(fields[6+i], fontsize=14)
ax.grid()
ax.set_xlabel('id', fontsize=14)
ax.set_ylabel('feature value', fontsize=14)
fig.suptitle('Haralick Features Distribution', fontsize=16)
fig.show()
Explanation: Distribution of 12 features
Let's look into the data first.
Plot and compare the distribution of 12 features on same region.
End of explanation
BRAIN_N = 173 # Which brain would you like to study?
tmp = data[data[:,1]==BRAIN_N,:]
fig = plt.figure(figsize=(16,24))
for i,field in enumerate(fields[6:]):
ax = fig.add_subplot(7,2,i+1, projection='3d')
ax.set_title(field, fontsize=16)
s = (tmp[:,6+i]-min(tmp[:,6+i]))/max(tmp[:,6+i])*80+20
ax.scatter(tmp[:,3], tmp[:,4], tmp[:,5],s=s, c='b', marker='o', alpha=0.4)
ax.autoscale(tight=True)
ax.set_xlabel('x', fontsize=14)
ax.set_ylabel('y', fontsize=14)
ax.set_zlabel('z', fontsize=14)
fig.suptitle('Haralick Features 3D position plot of brain %d'%(BRAIN_N), fontsize=16)
fig.show()
Explanation: ROI 3D position plot
End of explanation |
3,449 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
USA UFO sightings (Python 3 version)
This notebook is based on the first chapter sample from Machine Learning for Hackers with some added features. I did this to present Jupyter Notebook with Python 3 for Tech Days in my Job.
The original link is offline so you need to download the file from the author's repository inside ../data form the r notebook directory.
I will assume the following questions need to be aswers;
- What is the best place to have UFO sightings on USA?
- What is the best month to have UFO sightings on USA?
Loading the data
This first session will handle with loading the main data file using Pandas.
Step1: Here we are loading the dataset with pandas with a minimal set of options.
- sep
Step2: With the data loaded in ufo dataframe, lets check it composition and first set of rows.
Step3: The dataframe describe() show us how many itens (without NaN) each column have, how many are uniques, which is more frequent value, and how much this value appear. head() simply show us the first 5 rows (first is 0 on Python).
Dealing with metadata and column names
We need to handle the columns names, to do so is necessary to see the data document. The table bellow shows the fields details get from the metadata
Step4: Now we have a good looking dataframe with columns.
Step5: Data Wrangling
Now we start to transform our data into something to analyse.
Keeping only necessary data
To decide about this lets get back to the questions to be answers.
The first one is about the better place on USA to have UFO sightings, for this we will need the Location column, and in some place in time we will make filters for it. The second question is about the better month to have UFO sightings, which will lead to the DateOccurred column.
Based on this Shape and LongDescription columns can be stripped high now (it's a bit obvious for the data relevance). But there is 2 others columns which can or cannot be removed, DataRepoted and Duration.
I always keep in mind to maintain, at last util second order, columns with some useful information to use it on further data wrangling or to get some statistical sense of it. Both columns have a date (in a YYYYDDMM year format) and a string which can possibly store some useful information if have data treatment to convert it in some numeric format. For the purpose of this demo, I removing it because DateReported will not be used further (the main purpose of the date is when the sight occurs and not when it was registered) and Duration is a relly mess and for a example to show on a Tech Day the effort to decompose it is not worthing.
The drop() command bellow have the following parameters
Step6: Converting data
Now we are good to start the data transformation, the dates columns must be converted to Python date objects to allow manipulation of theirs time series.
The first problem will happens when trying to run this code using pandas.to_datetime() to convert the string
Step7: The column now is a datetime object and have 60814 against the original 61069 elements, which shows some bad dates are gone. The following code show us how many elements was removed.
Step8: There is no surprise that 60814 + 255 = 61069, we need to deal with this values too.
So we have a field DateOccurred with some NaN values. In this point we need to make a importante decision, get rid of the columns with NaN dates or fill it with something.
There is no universal guide to this, we could fill it with the mean of the column or copy the content of the DateReported column. But in this case the missing date is less then 0.5% of the total, so for the simplicity sakes we will simply drop all NaN values.
Step9: With the dataframe with clean dates, lets create another 2 columns to handle years and months in separate. This will make some analysis more easy (like discover which is the better month of year to look for UFO sights).
Step10: A funny thing about year is the most old sight is in 1762! This dataset includes sights from history.
How can this be significative? Well, to figure it out its time to plot some charts. The humans are visual beings and a picture really worth much more than a bunch of numbers and words.
To do so we will use the default matplotlib library from Python to build our graphs.
Analysing the years
Before start lets count the sights by year.
The comands bellow are equivalent to the following SQL code
Step11: We can see the number of sightings is more representative after around 1900, so we will filter the dataframe for all year above this threshold.
Step12: Handling location
Here we will make two steps, first is splitting all locations is city and states, for USA only. Second is load a dataset having the latitude and longitude for each USA city for future merge. | Python Code:
import pandas as pd
import numpy as np
Explanation: USA UFO sightings (Python 3 version)
This notebook is based on the first chapter sample from Machine Learning for Hackers with some added features. I did this to present Jupyter Notebook with Python 3 for Tech Days in my Job.
The original link is offline so you need to download the file from the author's repository inside ../data form the r notebook directory.
I will assume the following questions need to be aswers;
- What is the best place to have UFO sightings on USA?
- What is the best month to have UFO sightings on USA?
Loading the data
This first session will handle with loading the main data file using Pandas.
End of explanation
ufo = pd.read_csv(
'../data/ufo_awesome.tsv',
sep = "\t",
header = None,
dtype = object,
na_values = ['', 'NaN'],
error_bad_lines = False,
warn_bad_lines = False
)
Explanation: Here we are loading the dataset with pandas with a minimal set of options.
- sep: once the file is in TSV format the separator is a <TAB> special character;
- na_values: the file have empty strings for NaN values;
- header: ignore any column as a header since the file lacks it;
- dtype: load the dataframe as objects, avoiding interpret the data types¹;
- error_bad_lines: ignore lines with more than the number of rows;
- warn_bad_lines: is set to false to avoid ugly warnings on the screen, activate this if you want to analyse the bad rows.
¹ Before start to make assumptions of the data I prefer load it as objects and then convert it after make sense of it. Also the data can be corrupted and make it impossible to cast.
End of explanation
ufo.describe()
ufo.head()
Explanation: With the data loaded in ufo dataframe, lets check it composition and first set of rows.
End of explanation
ufo.columns = [
'DateOccurred',
'DateReported',
'Location',
'Shape',
'Duration',
'LongDescription'
]
Explanation: The dataframe describe() show us how many itens (without NaN) each column have, how many are uniques, which is more frequent value, and how much this value appear. head() simply show us the first 5 rows (first is 0 on Python).
Dealing with metadata and column names
We need to handle the columns names, to do so is necessary to see the data document. The table bellow shows the fields details get from the metadata:
| Short name | Type | Description |
| ---------- | ---- | ----------- |
| sighted_at | Long | Date the event occurred (yyyymmdd) |
| reported_at | Long | Date the event was reported |
| location | String | City and State where event occurred |
| shape | String | One word string description of the UFO shape |
| duration | String | Event duration (raw text field) |
| description | String | A long, ~20-30 line, raw text description |
To keep in sync with the R example, we will set the columns names to the following values:
- DateOccurred
- DateReported
- Location
- Shape
- Duration
- LogDescription
End of explanation
ufo.head()
Explanation: Now we have a good looking dataframe with columns.
End of explanation
ufo.drop(
labels = ['DateReported', 'Duration', 'Shape', 'LongDescription'],
axis = 1,
inplace = True
)
ufo.head()
Explanation: Data Wrangling
Now we start to transform our data into something to analyse.
Keeping only necessary data
To decide about this lets get back to the questions to be answers.
The first one is about the better place on USA to have UFO sightings, for this we will need the Location column, and in some place in time we will make filters for it. The second question is about the better month to have UFO sightings, which will lead to the DateOccurred column.
Based on this Shape and LongDescription columns can be stripped high now (it's a bit obvious for the data relevance). But there is 2 others columns which can or cannot be removed, DataRepoted and Duration.
I always keep in mind to maintain, at last util second order, columns with some useful information to use it on further data wrangling or to get some statistical sense of it. Both columns have a date (in a YYYYDDMM year format) and a string which can possibly store some useful information if have data treatment to convert it in some numeric format. For the purpose of this demo, I removing it because DateReported will not be used further (the main purpose of the date is when the sight occurs and not when it was registered) and Duration is a relly mess and for a example to show on a Tech Day the effort to decompose it is not worthing.
The drop() command bellow have the following parameters:
- labels: columns to remove;
- axis: set to 1 to remove columns;
- inplace: set to True to modify the dataframe itself and return none.
End of explanation
ufo['DateOccurred'] = pd.Series([
pd.to_datetime(
date,
format = '%Y%m%d',
errors='coerce'
) for date in ufo['DateOccurred']
])
ufo.describe()
Explanation: Converting data
Now we are good to start the data transformation, the dates columns must be converted to Python date objects to allow manipulation of theirs time series.
The first problem will happens when trying to run this code using pandas.to_datetime() to convert the string:
python
ufo['DateOccurred'] = pd.Series([
pd.to_datetime(
date,
format = '%Y%m%d'
) for date in ufo['DateOccurred']
])
This will rise a serie of errors (stack trace) which is cause by this:
ValueError: time data '0000' does not match format '%Y%m%d' (match)
What happen here is bad data (welcome to the data science world, most of data will come corrupted, missing, wrong or with some other problem). Before proceed we need to deal with the dates with wrong format.
So what to do? Well we can make the to_datetime() method ignore the errors putting a NaT values on the field. Lets convert this and then see how the DataOccurred column will appear.
End of explanation
ufo['DateOccurred'].isnull().sum()
Explanation: The column now is a datetime object and have 60814 against the original 61069 elements, which shows some bad dates are gone. The following code show us how many elements was removed.
End of explanation
ufo.isnull().sum()
ufo.dropna(
axis = 0,
inplace = True
)
ufo.isnull().sum()
ufo.describe()
Explanation: There is no surprise that 60814 + 255 = 61069, we need to deal with this values too.
So we have a field DateOccurred with some NaN values. In this point we need to make a importante decision, get rid of the columns with NaN dates or fill it with something.
There is no universal guide to this, we could fill it with the mean of the column or copy the content of the DateReported column. But in this case the missing date is less then 0.5% of the total, so for the simplicity sakes we will simply drop all NaN values.
End of explanation
ufo['Year'] = pd.DatetimeIndex(ufo['DateOccurred']).year
ufo['Month'] = pd.DatetimeIndex(ufo['DateOccurred']).month
ufo.head()
ufo['Month'].describe()
ufo['Year'].describe()
Explanation: With the dataframe with clean dates, lets create another 2 columns to handle years and months in separate. This will make some analysis more easy (like discover which is the better month of year to look for UFO sights).
End of explanation
sightings_by_year = ufo.groupby('Year').size().reset_index()
sightings_by_year.columns = ['Year', 'Sightings']
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import seaborn as sns
plt.style.use('seaborn-white')
%matplotlib inline
plt.xticks(rotation = 90)
sns.barplot(
data = sightings_by_year,
x = 'Year',
y = 'Sightings',
color= 'blue'
)
ax = plt.gca()
ax.xaxis.set_major_locator(ticker.MultipleLocator(base=5))
Explanation: A funny thing about year is the most old sight is in 1762! This dataset includes sights from history.
How can this be significative? Well, to figure it out its time to plot some charts. The humans are visual beings and a picture really worth much more than a bunch of numbers and words.
To do so we will use the default matplotlib library from Python to build our graphs.
Analysing the years
Before start lets count the sights by year.
The comands bellow are equivalent to the following SQL code:
SQL
SELECT Year, count(*) AS Sightings
FROM ufo
GROUP BY Year
End of explanation
ufo = ufo[ufo['Year'] > 1900]
Explanation: We can see the number of sightings is more representative after around 1900, so we will filter the dataframe for all year above this threshold.
End of explanation
locations = ufo['Location'].str.split(', ').apply(pd.Series)
ufo['City'] = locations[0]
ufo['State'] = locations[1]
Explanation: Handling location
Here we will make two steps, first is splitting all locations is city and states, for USA only. Second is load a dataset having the latitude and longitude for each USA city for future merge.
End of explanation |
3,450 | Given the following text problem statement, write Python code to implement the functionality described below in problem statement
Problem:
I'm trying to reduce noise in a binary python array by removing all completely isolated single cells, i.e. setting "1" value cells to 0 if they are completely surrounded by other "0"s like this: | Problem:
import numpy as np
import scipy.ndimage
square = np.zeros((32, 32))
square[10:-10, 10:-10] = 1
np.random.seed(12)
x, y = (32*np.random.random((2, 20))).astype(int)
square[x, y] = 1
def filter_isolated_cells(array, struct):
filtered_array = np.copy(array)
id_regions, num_ids = scipy.ndimage.label(filtered_array, structure=struct)
id_sizes = np.array(scipy.ndimage.sum(array, id_regions, range(num_ids + 1)))
area_mask = (id_sizes == 1)
filtered_array[area_mask[id_regions]] = 0
return filtered_array
square = filter_isolated_cells(square, struct=np.ones((3,3))) |
3,451 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Screening curve analysis
Compute the long-term equilibrium power plant investment for a given load duration curve (1000-1000z for z $\in$ [0,1]) and a given set of generator investment options.
Step1: Generator marginal (m) and capital (c) costs in EUR/MWh - numbers chosen for simple answer.
Step2: The screening curve intersections are at 0.01 and 0.5.
Step3: The capacity is set by total electricity required.
NB
Step4: The prices correspond either to VOLL (1012) for first 0.01 or the marginal costs (12 for 0.49 and 2 for 0.5)
Except for (infinitesimally small) points at the screening curve intersections, which correspond to changing the load duration near the intersection, so that capacity changes. This explains 7 = (12+10 - 15) (replacing coal with gas) and 22 = (12+10) (replacing load-shedding with gas).
Note
Step5: Demonstrate zero-profit condition.
The total cost is given by
Step6: The total revenue by
Step7: Now, take the capacities from the above long-term equilibrium, then disallow expansion.
Show that the resulting market prices are identical.
This holds in this example, but does NOT necessarily hold and breaks down in some circumstances (for example, when there is a lot of storage and inter-temporal shifting).
Step8: Demonstrate zero-profit condition. Differences are due to singular times, see above, not a problem
Total costs
Step9: Total revenue | Python Code:
import pypsa
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
Explanation: Screening curve analysis
Compute the long-term equilibrium power plant investment for a given load duration curve (1000-1000z for z $\in$ [0,1]) and a given set of generator investment options.
End of explanation
generators = {
"coal": {"m": 2, "c": 15},
"gas": {"m": 12, "c": 10},
"load-shedding": {"m": 1012, "c": 0},
}
Explanation: Generator marginal (m) and capital (c) costs in EUR/MWh - numbers chosen for simple answer.
End of explanation
x = np.linspace(0, 1, 101)
df = pd.DataFrame(
{key: pd.Series(item["c"] + x * item["m"], x) for key, item in generators.items()}
)
df.plot(ylim=[0, 50], title="Screening Curve", figsize=(9, 5))
plt.tight_layout()
n = pypsa.Network()
num_snapshots = 1001
n.snapshots = np.linspace(0, 1, num_snapshots)
n.snapshot_weightings = n.snapshot_weightings / num_snapshots
n.add("Bus", name="bus")
n.add("Load", name="load", bus="bus", p_set=1000 - 1000 * n.snapshots.values)
for gen in generators:
n.add(
"Generator",
name=gen,
bus="bus",
p_nom_extendable=True,
marginal_cost=float(generators[gen]["m"]),
capital_cost=float(generators[gen]["c"]),
)
n.loads_t.p_set.plot.area(title="Load Duration Curve", figsize=(9, 5), ylabel="MW")
plt.tight_layout()
n.lopf(solver_name="cbc")
n.objective
Explanation: The screening curve intersections are at 0.01 and 0.5.
End of explanation
n.generators.p_nom_opt.round(2)
n.buses_t.marginal_price.plot(title="Price Duration Curve", figsize=(9, 4))
plt.tight_layout()
Explanation: The capacity is set by total electricity required.
NB: No load shedding since all prices are below 10 000.
End of explanation
n.buses_t.marginal_price.round(2).sum(axis=1).value_counts()
n.generators_t.p.plot(ylim=[0, 600], title="Generation Dispatch", figsize=(9, 5))
plt.tight_layout()
Explanation: The prices correspond either to VOLL (1012) for first 0.01 or the marginal costs (12 for 0.49 and 2 for 0.5)
Except for (infinitesimally small) points at the screening curve intersections, which correspond to changing the load duration near the intersection, so that capacity changes. This explains 7 = (12+10 - 15) (replacing coal with gas) and 22 = (12+10) (replacing load-shedding with gas).
Note: What remains unclear is what is causing \l = 0... it should be 2.
End of explanation
(
n.generators.p_nom_opt * n.generators.capital_cost
+ n.generators_t.p.multiply(n.snapshot_weightings.generators, axis=0).sum()
* n.generators.marginal_cost
)
Explanation: Demonstrate zero-profit condition.
The total cost is given by
End of explanation
(
n.generators_t.p.multiply(n.snapshot_weightings.generators, axis=0)
.multiply(n.buses_t.marginal_price["bus"], axis=0)
.sum(0)
)
Explanation: The total revenue by
End of explanation
n.generators.p_nom_extendable = False
n.generators.p_nom = n.generators.p_nom_opt
n.lopf();
n.buses_t.marginal_price.plot(title="Price Duration Curve", figsize=(9, 5))
plt.tight_layout()
n.buses_t.marginal_price.sum(axis=1).value_counts()
Explanation: Now, take the capacities from the above long-term equilibrium, then disallow expansion.
Show that the resulting market prices are identical.
This holds in this example, but does NOT necessarily hold and breaks down in some circumstances (for example, when there is a lot of storage and inter-temporal shifting).
End of explanation
(
n.generators.p_nom * n.generators.capital_cost
+ n.generators_t.p.multiply(n.snapshot_weightings.generators, axis=0).sum()
* n.generators.marginal_cost
)
Explanation: Demonstrate zero-profit condition. Differences are due to singular times, see above, not a problem
Total costs
End of explanation
(
n.generators_t.p.multiply(n.snapshot_weightings.generators, axis=0)
.multiply(n.buses_t.marginal_price["bus"], axis=0)
.sum()
)
Explanation: Total revenue
End of explanation |
3,452 | Given the following text problem statement, write Python code to implement the functionality described below in problem statement
Problem:
pandas version: 1.2 | Problem:
import pandas as pd
df = pd.DataFrame([(.21, .3212), (.01, .61237), (.66123, pd.NA), (.21, .18),(pd.NA, .188)],
columns=['dogs', 'cats'])
def g(df):
for i in df.index:
if str(df.loc[i, 'dogs']) != '<NA>' and str(df.loc[i, 'cats']) != '<NA>':
df.loc[i, 'dogs'] = round(df.loc[i, 'dogs'], 2)
df.loc[i, 'cats'] = round(df.loc[i, 'cats'], 2)
return df
df = g(df.copy()) |
3,453 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<img src="img/CSDMS-logo.png">
BMI Live!
Let's use this notebook to test our BMI as we develop it.
Setup
Before we start, make sure you've installed the bmipy package
Step1: Test the BMI methods
Start by importing the BmiDiffusion class from the bmi-live package
Step2: Create an instance of the model's BMI.
Step3: What's the name of this component?
Step4: Show the input and output variables for the component
Step5: Locate a sample configuration file included with the bmi-live package
Step6: Use the sample configuration to initialize the Diffusion model through its BMI
Step7: Check the time information for the model.
Step8: Next, get attributes of the grid on which the temperature variable is defined
Step9: Get the model's initial temperature field through the BMI
Step10: Add an impulse to the initial temperature field
Step11: Check that the temperature field has been updated
Step12: Now advance the model by a single time step
Step13: View the new state of the temperature field
Step14: There's diffusion!
Advance another step
Step15: View the new state of the temperature field (with help from np.set_printoptions)
Step16: Advance the model to some distant time
Step17: View the new state of the temperature field
Step18: Finalize the model | Python Code:
import os
import numpy as np
Explanation: <img src="img/CSDMS-logo.png">
BMI Live!
Let's use this notebook to test our BMI as we develop it.
Setup
Before we start, make sure you've installed the bmipy package:
$ conda install bmipy -c conda-forge
Also install our bmi-live package in developer mode:
$ python setup.py develop
Last, a pair of imports for later:
End of explanation
from bmi_live import BmiDiffusion
Explanation: Test the BMI methods
Start by importing the BmiDiffusion class from the bmi-live package:
End of explanation
x = BmiDiffusion()
Explanation: Create an instance of the model's BMI.
End of explanation
print(x.get_component_name())
Explanation: What's the name of this component?
End of explanation
print(x.get_input_var_names())
print(x.get_output_var_names())
Explanation: Show the input and output variables for the component:
End of explanation
from bmi_live import data_directory
cfg_file = os.path.join(data_directory, 'diffusion.yaml')
Explanation: Locate a sample configuration file included with the bmi-live package:
End of explanation
x.initialize(cfg_file)
Explanation: Use the sample configuration to initialize the Diffusion model through its BMI:
End of explanation
print('Start time:', x.get_start_time())
print('End time:', x.get_end_time())
print('Current time:', x.get_current_time())
print('Time step:', x.get_time_step())
print('Time units:', x.get_time_units())
Explanation: Check the time information for the model.
End of explanation
grid_id = x.get_var_grid('plate_surface__temperature')
print('Grid id:', grid_id)
grid_rank = x.get_grid_rank(grid_id)
print('Grid rank:', grid_rank)
grid_shape = np.ndarray(grid_rank, int)
x.get_grid_shape(grid_id, grid_shape)
print('Grid shape:', grid_shape)
grid_spacing = np.ndarray(grid_rank, float)
x.get_grid_spacing(grid_id, grid_spacing)
print('Grid spacing:', grid_spacing)
print('Grid type:', x.get_grid_type(grid_id))
Explanation: Next, get attributes of the grid on which the temperature variable is defined:
End of explanation
temp = np.ndarray(grid_shape).flatten() #flattened!
x.get_value('plate_surface__temperature', temp)
print(temp.reshape(grid_shape)) # dimensional
Explanation: Get the model's initial temperature field through the BMI:
End of explanation
temp[20] = 100.0
x.set_value('plate_surface__temperature', temp)
Explanation: Add an impulse to the initial temperature field:
End of explanation
x.get_value('plate_surface__temperature', temp)
print(temp.reshape(grid_shape))
Explanation: Check that the temperature field has been updated:
End of explanation
x.update()
Explanation: Now advance the model by a single time step:
End of explanation
x.get_value('plate_surface__temperature', temp)
print(temp.reshape(grid_shape))
Explanation: View the new state of the temperature field:
End of explanation
x.update()
Explanation: There's diffusion!
Advance another step:
End of explanation
x.get_value('plate_surface__temperature', temp)
np.set_printoptions(formatter={'float': '{: 6.2f}'.format})
print(temp.reshape(grid_shape))
Explanation: View the new state of the temperature field (with help from np.set_printoptions):
End of explanation
distant_time = 5.0
while x.get_current_time() < distant_time:
x.update()
Explanation: Advance the model to some distant time:
End of explanation
x.get_value('plate_surface__temperature', temp)
print(temp.reshape(grid_shape))
Explanation: View the new state of the temperature field:
End of explanation
x.finalize()
Explanation: Finalize the model:
End of explanation |
3,454 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Multi-layer Neural Network
By virture of being here, it is assumed that you have gone through the Quick Start. To recap the Quicks tart tutorial, We imported MNIST dataset and trained a Logistic Regression which produces a linear classification boundary. It is impossible to learn complex functions like XOR with linear classification boundary.
A Neural Network is a function approximator consisting of several neurons organized in a layered fashion. Each neuron takes input from previous layer, performs some mathematical calculation and sends output to next layer. A neuron produces output only if the result of the calculation it performs is greater than some threshold. This threshold function is called activation function. Depending on the type of the task different activation functions can be used. Some of the most commonly used activation functions are sigmoid, tanh, ReLu and maxout. It is inspired from the functioning of human brain where one neuron sends signal to other neuron only if the electical signal in the first neuron is greater than some threshold.
A Feed Forward Neural network/ multi-layer perceptron has an input layer, an output layer and some hidden layers. The actual magic of the neural networks happens in the hidden layers and they represent the function the network is trying to approximate. Output layer is generally a softmax function that converts the inputs into probabilities. Let us look at the mathematical representation of the hidden layer and output layer
Hidden layer
Step1: In Instead of connecting this to a classfier as we saw in the Quick Start , let us add a couple of fully connected hidden layers. Hidden layers can be created using layer type = dot_product.
Step2: Notice the parameters passed. num_neurons is the number of nodes in the layer. Notice also how we modularized the layers by using the id parameter. origin represents which layer will be the input to the new layer. By default yann assumes all layers are input serially and chooses the last added layer to be the input. Using origin, one can create various types of architectures. Infact any directed acyclic graphs (DAGs) that could be hand-drawn could be implemented. Let us now add a classifier and an objective layer to this.
Step3: The following block is something we did not use in the Quick Start tutorial. We are adding optimizer and optimizer parameters to the network. Let us create our own optimizer module this time instead of using the yann default. For any module in yann, the initialization can be done using the add_module method. The add_module method typically takes input type which in this case is optimizer and a set of intitliazation parameters which in our case is params = optimizer_params. Any module params, which in this case is the optimizer_params is a dictionary of relevant options. If you are not familiar with the optimizers in neural network, I would suggest you to go through the Optimizers to Neural network series of tutorials to get familiar with the effect of differnt optimizers in a Nueral Network.
A typical optimizer setup is
Step4: We have now successfully added a Polyak momentum with RmsProp back propagation with some and co-efficients that will be applied to the layers for which we passed as argument regularize = True. For more options of parameters on optimizer refer to the optimizer documentation . This optimizer will therefore solve the following error
Step5: The learning_rate, supplied here is a tuple. The first indicates a annealing of a linear rate, the second is the initial learning rate of the first era, and the third value is the leanring rate of the second era. Accordingly, epochs takes in a tuple with number of epochs for each era.
Noe we can cook, train and test as usual
Step6: This time, let us not let it run the forty epochs, let us cancel in the middle after some epochs by hitting ^c. Once it stops lets immediately test and demonstrate that the net retains the parameters as updated as possible.
Some new arguments are introduced here and they are for the most part easy to understand in context. epoch represents a tuple which is the number of epochs of training and number of epochs of fine tuning epochs after that. There could be several of these stages of finer tuning. Yann uses the term ‘era’ to represent each set of epochs running with one learning rate. show_progress will print a progress bar for each epoch. validate_after_epochs will perform validation after such many epochs on a different validation dataset.
Once done, lets run net.test()
Step7: The full code for this tutorial with additional commentary can be found in the file pantry.tutorials.mlp.py. If you have toolbox cloned or downloaded or just the tutorials downloaded, Run the code as, | Python Code:
from yann.network import network
from yann.special.datasets import cook_mnist
data = cook_mnist()
dataset_params = { "dataset": data.dataset_location(), "id": 'mnist', "n_classes" : 10 }
net = network()
net.add_layer(type = "input", id ="input", dataset_init_args = dataset_params)
Explanation: Multi-layer Neural Network
By virture of being here, it is assumed that you have gone through the Quick Start. To recap the Quicks tart tutorial, We imported MNIST dataset and trained a Logistic Regression which produces a linear classification boundary. It is impossible to learn complex functions like XOR with linear classification boundary.
A Neural Network is a function approximator consisting of several neurons organized in a layered fashion. Each neuron takes input from previous layer, performs some mathematical calculation and sends output to next layer. A neuron produces output only if the result of the calculation it performs is greater than some threshold. This threshold function is called activation function. Depending on the type of the task different activation functions can be used. Some of the most commonly used activation functions are sigmoid, tanh, ReLu and maxout. It is inspired from the functioning of human brain where one neuron sends signal to other neuron only if the electical signal in the first neuron is greater than some threshold.
A Feed Forward Neural network/ multi-layer perceptron has an input layer, an output layer and some hidden layers. The actual magic of the neural networks happens in the hidden layers and they represent the function the network is trying to approximate. Output layer is generally a softmax function that converts the inputs into probabilities. Let us look at the mathematical representation of the hidden layer and output layer
Hidden layer:
let $[a_{i-1}^1], a_{i-1}^2, a_{i-1}^3 ........ a_{i-1}^n]$ be the activations of the previous layer $i-1$
$$h_i = w_i^0 + w_i^1a_{i-1}^1 + w_i^2a_{i-1}^2 + ...... + w_i^na_{i-1}^n$$
$$a_i = act(h_i)$$
Where i is the layer number,
$[w_i^1, w_i^2, w_i^3, ......... w_i^n]$ be the parameters between the $i^{th}$ and $(i-1)^{th}$ layer, $w_i^0$ is the bias which is the input when there is no activation from the previous layer,
1,2....n are the dimensions of the layer,
$a_i$ is the activation at the layer, and $act()$ is the activation function for that layer.
Output layer:
let our network has l layers
$$z = w_i^0 + w_i^1a_{i-1}^1 + w_i^2a_{i-1}^2 + ...... + w_i^na_{i-1}^n$$
$$a = softmax(z)$$
$$correct class = argmax(a)$$
Where a represents the output probabilities, z represents the weighted activations of the previous layer.
Neural Network training:-
Neural Network has a lot of parameters to learn. Consider a neural network with 2 layers of each 100 neurons and input dimension of 1024 and 10 outputs. Then the number of parameters to learn is 1024 * 100 * 100 * 10 i.e., 102400000 parameters. Learning these many parameters is a complex task because for each parameter we need to calculate the gradient of error function and update the parameters with that gradient. The computational instability of this process is the reason for neural networks to loose it's charm quickly. There is a technique called Back propagation that solved this problem. The following section gives a brief insight into the backpropagation technique.
Back Propagation:
YANN handles the Back propagation by itself. But, it does not hurt to know how it works. A neural network can be represented mathematically as $$O = f_1(W_l(f_2(W_{l-1}f_3(..f_n(WX)..)))$$ where $f_1, f_2, f_3$ are activation functions.
An Error function can be represented as $$E(f_1(W_l(f_2(W_{l-1}f_3(..f_n(WX)..))))$$ where $E()$ is some error function. The gradient of $W_l$ is given by:
$$g_l = \frac{\partial E(f_1(W_lf_2(W_{l-1}f_3(..f_n(WX)..))))}{\partial W_l} $$
Applying chain rule:
$$g_l = \frac{\partial E(f_1())}{\partial f_1}\frac{\partial f_1}{\partial W_l}
$$
The gradient of error w.r.t $W_{l-1}$ after applying chain rule:
$$g_l = \frac{\partial E(f_1())}{\partial f_1}\frac{\partial f_1(W_lf_2())}{\partial f_2}\frac{\partial f_2()}{\partial W_2}
$$
In the above equations the first term $\frac{\partial E(f_1())}{\partial f_1}$ remains same for both gradients. Similarly for rest of the parameters we reuse the terms from the previous gradient calculation. This process drastically reduces the number of calculations in Neural Network training.
Let us take this one step further and create a neural network with two hidden layers. We begin as usual by importing the network class and creating the input layer.
End of explanation
net.add_layer (type = "dot_product",
origin ="input",
id = "dot_product_1",
num_neurons = 800,
regularize = True,
activation ='relu')
net.add_layer (type = "dot_product",
origin ="dot_product_1",
id = "dot_product_2",
num_neurons = 800,
regularize = True,
activation ='relu')
Explanation: In Instead of connecting this to a classfier as we saw in the Quick Start , let us add a couple of fully connected hidden layers. Hidden layers can be created using layer type = dot_product.
End of explanation
net.add_layer ( type = "classifier",
id = "softmax",
origin = "dot_product_2",
num_classes = 10,
activation = 'softmax',
)
net.add_layer ( type = "objective",
id = "nll",
origin = "softmax",
)
Explanation: Notice the parameters passed. num_neurons is the number of nodes in the layer. Notice also how we modularized the layers by using the id parameter. origin represents which layer will be the input to the new layer. By default yann assumes all layers are input serially and chooses the last added layer to be the input. Using origin, one can create various types of architectures. Infact any directed acyclic graphs (DAGs) that could be hand-drawn could be implemented. Let us now add a classifier and an objective layer to this.
End of explanation
optimizer_params = {
"momentum_type" : 'polyak',
"momentum_params" : (0.9, 0.95, 30),
"regularization" : (0.0001, 0.0002),
"optimizer_type" : 'rmsprop',
"id" : 'polyak-rms'
}
net.add_module ( type = 'optimizer', params = optimizer_params )
Explanation: The following block is something we did not use in the Quick Start tutorial. We are adding optimizer and optimizer parameters to the network. Let us create our own optimizer module this time instead of using the yann default. For any module in yann, the initialization can be done using the add_module method. The add_module method typically takes input type which in this case is optimizer and a set of intitliazation parameters which in our case is params = optimizer_params. Any module params, which in this case is the optimizer_params is a dictionary of relevant options. If you are not familiar with the optimizers in neural network, I would suggest you to go through the Optimizers to Neural network series of tutorials to get familiar with the effect of differnt optimizers in a Nueral Network.
A typical optimizer setup is:
End of explanation
learning_rates = (0.05, 0.01, 0.001)
Explanation: We have now successfully added a Polyak momentum with RmsProp back propagation with some and co-efficients that will be applied to the layers for which we passed as argument regularize = True. For more options of parameters on optimizer refer to the optimizer documentation . This optimizer will therefore solve the following error:
where is the error, is the sigmoid layer and is the ith layer of the network.
End of explanation
net.cook( optimizer = 'polyak-rms',
objective_layer = 'nll',
datastream = 'mnist',
classifier = 'softmax',
)
net.train( epochs = (20, 20),
validate_after_epochs = 2,
training_accuracy = True,
learning_rates = learning_rates,
show_progress = True,
early_terminate = True)
Explanation: The learning_rate, supplied here is a tuple. The first indicates a annealing of a linear rate, the second is the initial learning rate of the first era, and the third value is the leanring rate of the second era. Accordingly, epochs takes in a tuple with number of epochs for each era.
Noe we can cook, train and test as usual:
End of explanation
net.test()
Explanation: This time, let us not let it run the forty epochs, let us cancel in the middle after some epochs by hitting ^c. Once it stops lets immediately test and demonstrate that the net retains the parameters as updated as possible.
Some new arguments are introduced here and they are for the most part easy to understand in context. epoch represents a tuple which is the number of epochs of training and number of epochs of fine tuning epochs after that. There could be several of these stages of finer tuning. Yann uses the term ‘era’ to represent each set of epochs running with one learning rate. show_progress will print a progress bar for each epoch. validate_after_epochs will perform validation after such many epochs on a different validation dataset.
Once done, lets run net.test():-
End of explanation
from yann.pantry.tutorials.mlp import mlp
mlp(dataset = data.dataset_location())
Explanation: The full code for this tutorial with additional commentary can be found in the file pantry.tutorials.mlp.py. If you have toolbox cloned or downloaded or just the tutorials downloaded, Run the code as,
End of explanation |
3,455 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Analysis of Stochastic Processes ($\S$ 10.5)
If a system is always variable, but the variability is not (infinitely) predictable, then we have a stochastic process. Counter to what you may think, these processes can also be characterized.
Take a (stochastically varying) quasar which has both line and continuum emission and where the line emission is stimulated by the continuum. Since there is a physical separation between the regions that produce each type of emission, we get a delay between the light curves as can be seen here
Step1: You should find that, because the power at high frequency is larger for $1/f$, that light curve will look noisier.
We can even hear the difference
Step2: ACF for Unevenly Sampled Data
astroML also has tools for computing the ACF of unevenly sampled data using two different (Scargle) and (Edelson & Krolik) methods
Step3: Figure 10.30 below gives an example of an ACF for a DRW, which mimics the variability that we might see from a quasar. (Note that the Scargle method doesn't seem to be working.)
Step4: Autoregressive Models
For processes like these that are not periodic, but that "retain memory" of previous states, we can use autogressive models.
A random walk is an example of such a process; every new value is given by the preceeding value plus some noise | Python Code:
import numpy as np
from matplotlib import pyplot as plt
from astroML.time_series import generate_power_law
from astroML.fourier import PSD_continuous
N = 2014
dt = 0.01
beta = 2
t = dt * np.arange(N)
y = generate_power_law(# Complete
f, PSD = PSD_continuous(# Complete
fig = plt.figure(figsize=(8, 4))
ax1 = fig.add_subplot(121)
ax1.plot(t, y, '-k')
ax1.set_xlim(0, 10)
ax2 = fig.add_subplot(122, xscale='log', yscale='log')
ax2.plot(f, PSD, '-k')
ax2.set_xlim(1E-1, 60)
ax2.set_ylim(1E-11, 1E-3)
plt.show()
Explanation: Analysis of Stochastic Processes ($\S$ 10.5)
If a system is always variable, but the variability is not (infinitely) predictable, then we have a stochastic process. Counter to what you may think, these processes can also be characterized.
Take a (stochastically varying) quasar which has both line and continuum emission and where the line emission is stimulated by the continuum. Since there is a physical separation between the regions that produce each type of emission, we get a delay between the light curves as can be seen here:
To understand stochastic processes, let's first talk about correlation functions. A correlation function ($\S$ 6.5) gives us information about the time delay between 2 processes. If one time series is derived from another simply by shifting the time axis by $t_{\rm lag}$, then their correlation function will have a peak at $\Delta t = t_{\rm lag}$.
The correlation function between $f(t)$, and $g(t)$ is defined as
$${\rm CF}(\Delta t) = \frac{\lim_{T\rightarrow \infty}\frac{1}{T}\int_T f(t)g(t+\Delta t)dt }{\sigma_f \sigma_g}$$
Computing the correlation function is basically the mathematical processes of sliding the two curves over each other and computing the degree of similarity for each step in time. The peak of the correlation function reveals the time delay between the processes. Below we have the correlation function of the line and continuum emission from a quasar, which reveals a $\sim$ 15 day delay between the two.
In an autocorrelation function (ACF), $f(t)= g(t)$ and we instead are revealing information about variability timescales present in a process.
If the values of $y$ are uncorrelated, then ACF$(\Delta t)=0$.
The Fourier Transform of an ACF is the Power Spectral Density (PSD). So, the PSD is an analysis in frequency space and the ACF is in time space. For example, for a sinusoidal function in time space, the ACF will have period, $T$, and the PSD in frequency space is a $\delta$ function centered on $\omega = 1/2\pi T$.
The structure function is another quantity that is frequently used in astronomy and is related to the ACF:
$${\rm SF}(\Delta t) = {\rm SF}_\infty[1 - {\rm ACF}(\Delta t)]^{1/2},$$
where ${\rm SF}_\infty$ is the standard deviation of the time series as evaluated on timescales much larger than any charateristic timescale.
If ${\rm SF} \propto t^{\alpha}$, then ${\rm PSD} \propto \frac{1}{f^{1+2\alpha}}$.
So an analysis of a stochastic system can be done with either the ACF, SF, or PSD.
AstroML has time series and Fourier tools for generating light curves drawn from a power law in frequency space. Note that these tools define $\beta = 1+2\alpha$. Complete the cell below to make a plot of counts vs. time and of the PSD vs. frequency for both a $1/f$ and a $1/f^2$ process. (Where the latter is known as Brownian motion or a random walk.)
End of explanation
# Ivezic, Figure 10.29
# Author: Jake VanderPlas
# License: BSD
# The figure produced by this code is published in the textbook
# "Statistics, Data Mining, and Machine Learning in Astronomy" (2013)
# For more information, see http://astroML.github.com
# To report a bug or issue, use the following forum:
# https://groups.google.com/forum/#!forum/astroml-general
import numpy as np
from matplotlib import pyplot as plt
from astroML.time_series import generate_power_law
from astroML.fourier import PSD_continuous
N = 1024
dt = 0.01
factor = 100
t = dt * np.arange(N)
random_state = np.random.RandomState(1)
fig = plt.figure(figsize=(5, 3.75))
fig.subplots_adjust(wspace=0.05)
for i, beta in enumerate([1.0, 2.0]):
# Generate the light curve and compute the PSD
x = factor * generate_power_law(N, dt, beta, random_state=random_state)
f, PSD = PSD_continuous(t, x)
# First axes: plot the time series
ax1 = fig.add_subplot(221 + i)
ax1.plot(t, x, '-k')
ax1.text(0.95, 0.05, r"$P(f) \propto f^{-%i}$" % beta,
ha='right', va='bottom', transform=ax1.transAxes)
ax1.set_xlim(0, 10.24)
ax1.set_ylim(-1.5, 1.5)
ax1.set_xlabel(r'$t$')
# Second axes: plot the PSD
ax2 = fig.add_subplot(223 + i, xscale='log', yscale='log')
ax2.plot(f, PSD, '-k')
ax2.plot(f[1:], (factor * dt) ** 2 * (2 * np.pi * f[1:]) ** -beta, '--k')
ax2.set_xlim(1E-1, 60)
ax2.set_ylim(1E-6, 1E1)
ax2.set_xlabel(r'$f$')
if i == 1:
ax1.yaxis.set_major_formatter(plt.NullFormatter())
ax2.yaxis.set_major_formatter(plt.NullFormatter())
else:
ax1.set_ylabel(r'${\rm counts}$')
ax2.set_ylabel(r'$PSD(f)$')
plt.show()
Explanation: You should find that, because the power at high frequency is larger for $1/f$, that light curve will look noisier.
We can even hear the difference:
https://www.youtube.com/watch?v=3vEDZ-_iLNU)
End of explanation
# Syntax for EK and Scargle ACF computation
import numpy as np
from astroML.time_series import generate_damped_RW
from astroML.time_series import ACF_scargle, ACF_EK
t = np.arange(0,1000)
y = generate_damped_RW(t, tau=300)
dy = 0.1
y = np.random.normal(y,dy)
ACF_scargle, bins_scargle = ACF_scargle(t,y,dy)
ACF_EK, ACF_err_EK, bins_EK = ACF_EK(t,y,dy)
Explanation: ACF for Unevenly Sampled Data
astroML also has tools for computing the ACF of unevenly sampled data using two different (Scargle) and (Edelson & Krolik) methods: http://www.astroml.org/modules/classes.html#module-astroML.time_series
One of the tools is for generating a damped random walk (DRW). Above we found that a random walk had a $1/f^2$ PSD. A damped random walk is a process "remembers" its history only for a characteristic time, $\tau$. The ACF vanishes for $\Delta t \gg \tau$.
End of explanation
# Ivezic, Figure 10.30
# Author: Jake VanderPlas
# License: BSD
# The figure produced by this code is published in the textbook
# "Statistics, Data Mining, and Machine Learning in Astronomy" (2013)
# For more information, see http://astroML.github.com
# To report a bug or issue, use the following forum:
# https://groups.google.com/forum/#!forum/astroml-general
import numpy as np
from matplotlib import pyplot as plt
from astroML.time_series import lomb_scargle, generate_damped_RW
from astroML.time_series import ACF_scargle, ACF_EK
#------------------------------------------------------------
# Generate time-series data:
# we'll do 1000 days worth of magnitudes
t = np.arange(0, 1E3)
z = 2.0
tau = 300
tau_obs = tau / (1. + z)
np.random.seed(6)
y = generate_damped_RW(t, tau=tau, z=z, xmean=20)
# randomly sample 100 of these
ind = np.arange(len(t))
np.random.shuffle(ind)
ind = ind[:100]
ind.sort()
t = t[ind]
y = y[ind]
# add errors
dy = 0.1
y_obs = np.random.normal(y, dy)
#------------------------------------------------------------
# compute ACF via scargle method
C_S, t_S = ACF_scargle(t, y_obs, dy, n_omega=2 ** 12, omega_max=np.pi / 5.0)
ind = (t_S >= 0) & (t_S <= 500)
t_S = t_S[ind]
C_S = C_S[ind]
#------------------------------------------------------------
# compute ACF via E-K method
C_EK, C_EK_err, bins = ACF_EK(t, y_obs, dy, bins=np.linspace(0, 500, 51))
t_EK = 0.5 * (bins[1:] + bins[:-1])
#------------------------------------------------------------
# Plot the results
fig = plt.figure(figsize=(8, 8))
# plot the input data
ax = fig.add_subplot(211)
ax.errorbar(t, y_obs, dy, fmt='.k', lw=1)
ax.set_xlabel('t (days)')
ax.set_ylabel('observed flux')
# plot the ACF
ax = fig.add_subplot(212)
ax.plot(t_S, C_S, '-', c='gray', lw=1, label='Scargle')
ax.errorbar(t_EK, C_EK, C_EK_err, fmt='.k', lw=1, label='Edelson-Krolik')
ax.plot(t_S, np.exp(-abs(t_S) / tau_obs), '-k', label='True')
ax.legend(loc=3)
ax.plot(t_S, 0 * t_S, ':', lw=1, c='gray')
ax.set_xlim(0, 500)
ax.set_ylim(-1.0, 1.1)
ax.set_xlabel('t (days)')
ax.set_ylabel('ACF(t)')
plt.show()
Explanation: Figure 10.30 below gives an example of an ACF for a DRW, which mimics the variability that we might see from a quasar. (Note that the Scargle method doesn't seem to be working.)
End of explanation
%matplotlib inline
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.ticker import MultipleLocator
N=10
#epsilon = np.array([0,0,0,1,0,0,0,0,0,0,0,0])
epsilon = np.zeros(N+2)
epsilon[3] = 1
yAR=np.zeros(N+2)
yMA=np.zeros(N+2)
yARMA=np.zeros(N+2)
for i in np.arange(N)+2:
# Complete using the coefficients given in the legend text below
yAR[i] =
yMA[i] =
yARMA[i] =
#print i, yAR[i], yMA[i]
fig = plt.figure(figsize=(6, 6))
t = np.arange(len(yAR))
plt.plot(t,yAR,label="AR(2), a_1=0.5, a_2=0.5")
plt.plot(t,yMA,label="MA(2), b_1=0.5, b_2=0.5")
plt.plot(t,yARMA,label="ARMA(2,1), a_1=0.5, a_2=0.25, b_1=0.5",zorder=0)
plt.xlabel("t")
plt.ylabel("y")
plt.legend(loc="upper right",prop={'size':8})
plt.ylim([0,1.1])
ax = plt.axes()
ax.xaxis.set_major_locator(plt.MultipleLocator(1.0))
plt.show()
Explanation: Autoregressive Models
For processes like these that are not periodic, but that "retain memory" of previous states, we can use autogressive models.
A random walk is an example of such a process; every new value is given by the preceeding value plus some noise:
$$y_i = y_{i-1} + \epsilon_i.$$
If the coefficient of $y_{i-1}$ is $>1$ then it is known as a geometric random walk, which is typical of the stock market. (So, when you interview for a quant position on Wall Street, you tell them that you are an expert in using autoregressive geometric random walks to model stochastic processes.)
In the random walk case above, each new value depends only on the immediately preceeding value. But we can generalized this to include $p$ values:
$$y_i = \sum_{j=1}^pa_jy_{i-j} + \epsilon_i$$
We refer to this as an autoregressive (AR) process of order $p$: $AR(p)$. For a random walk, we have $p=1$, and $a_1=1$.
If the data are drawn from a "stationary" process (one where it doesn't matter what region of the light curve you sample [so long as it is representative]), the $a_j$ satisfy certain conditions.
One thing that we might do then is ask whether a system is more consistent with $a_1=0$ or $a_1=1$ (noise vs. a random walk).
Below are some example light curves for specific $AR(p)$ processes. In the first example, $AR(0)$, the light curve is simply responding to noise fluctuations. In the second example, $AR(1)$, the noise fluctuation responses are persisting for slightly longer as the next time step depends positively on the time before. For the 3rd example, nearly the full effect of the noise spike from the previous time step is applied again, giving particularly long and high chains of peaks and valleys. In the 4th example, $AR(2)$, we have long, but low chains of peaks and valleys as a spike persists for an extra time step. Finally, in the 5th example, the response of a spike in the second time step has the opposite sign as for the first time step, and both have large coefficients, so the peaks and valleys are both quite high and quite narrowly separated.
A moving average (MA) process is similar in some ways to an AR process, but is different in other ways. It is defined as
$$y_i = \epsilon_i + \sum_{j=1}^qb_j\epsilon_{i-j}.$$
So, for example, an MA(q=1) process would look like
$$y_i = \epsilon_{i} + b_1\epsilon_{i-1},$$
whereas an AR(p=2) process would look like
$$y_i = a_1y_{i-1} + a_2y_{i-2} + \epsilon_i$$
Thus the $MA$ process is similar to an $AR$ process in that the next time step depends on the previous time step, but they are different in terms of how they respond to a shock. In an $MA$ process a shock affects only the current value and $q$ values into the future. In an $AR$ process a shock affects all future values.
Below is some code and a plot that illustrates this.
End of explanation |
3,456 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Quick start
PHIDL allows you to create complex designs from simple shapes, and can output the result as GDSII files. The basic element of PHIDL is the Device, which is just a GDS cell with some additional functionality (for those unfamiliar with GDS designs, it can be thought of as a blank area to which you can add polygon shapes). The polygon shapes can also have Ports on them--these allow you to snap shapes together like Lego blocks. You can either hand-design your own polygon shapes, or there is a large library of pre-existing shapes you can use as well.
Brief introduction
This first section is an extremely short tutorial meant to give you an idea of what PHIDL can do. For a more detailed tutorial, please read the following "The basics of PHIDL" section and the other tutorials.
We'll start with some boilerplate imports
Step1: Then let's create a blank Device (essentially an empty GDS cell with some special features)
Step2: Next let's add a custom polygon using lists of x points and y points. You can also add polygons pair-wise like [(x1,y1), (x2,y2), (x3,y3), ... ]. We'll also image the shape using the handy quickplot() function (imported here as qp())
Step3: You can also create new geometry using the built-in geometry library
Step4: We can easily add these new geometries to D, which currently contains our custom polygon. (For more details about references see below, or the tutorial called "Understanding References".)
Step5: Now that the geometry has been added to D, we can move and rotate everything however we want
Step6: We can also connect shapes together using their Ports, allowing us to snap shapes together like Legos. Let's add another arc and snap it to the end of the first arc
Step7: That's it for the very basics! Keep reading for a more detailed explanation of each of these, or see the other tutorials for topics such as using Groups, creating smooth Paths, and more.
The basics of PHIDL
This is a longer tutorial meant to explain the basics of PHIDL in a little more depth. Further explanation can be found in the other tutorials as well.
PHIDL allows you to create complex designs from simple shapes, and can output the result as GDSII files. The basic element of PHIDL is the Device, which can be thought of as a blank area to which you can add polygon shapes. The polygon shapes can also have Ports on them--these allow you to snap shapes together like Lego blocks. You can either hand-design your own polygon shapes, or there is a large library of pre-existing shapes you can use as well.
Creating a custom shape
Let's start by trying to make a rectangle shape with ports on either end.
Step8: Next, let's add Ports to the rectangle which will allow us to connect it to other shapes easily
Step9: We can check to see that our Device has ports in it using the print command
Step10: Looks good!
Library & combining shapes
Since this Device is finished, let's create a new (blank) Device and add several shapes to it. Specifically, we will add an arc from the built-in geometry library and two copies of our rectangle Device. We'll then then connect the rectangles to both ends of the arc. The arc() function is contained in the phidl.geometry library which as you can see at the top of this example is imported with the name pg.
This process involves adding "references". These references allow you to create a Device shape once, then reuse it many times in other Devices.
Step11: Now we can see we have added 3 shapes to our Device "E"
Step12: Looks great!
Going a level higher
Now we've made a (somewhat) complicated bend-shape from a few simple shapes. But say we're not done yet -- we actually want to combine together 3 of these bend-shapes to make an even-more complicated shape. We could recreate the geometry 3 times and manually connect all the pieces, but since we already put it together once it will be smarter to just reuse it multiple times.
We will start by abstracting this bend-shape. As shown in the quickplot, there are ports associated with each reference in our bend-shape Device E
Step13: It has no ports apparently! Why is that, when we clearly see ports in the quickplots above?
The answer is that Device E itself doesn't have ports -- the references inside E do have ports, but we never actually added ports to E. Let's fix that now, adding a port at either end, setting the names to the integers 1 and 2.
Step14: If we look at the quickplot above, we can see that there are now red-colored ports on both ends. Ports that are colored red are owned by the Device, ports that are colored blue-green are owned by objects inside the Device. This is good! Now if we want to use this bend-shape, we can interact with its ports named 1 and 2.
Let's go ahead and try to string 3 of these bend-shapes together
Step15: Saving as a GDSII file
Saving the design as a GDS file is simple -- just specify the Device you'd like to save and run the write_gds() function
Step16: Some useful notes about writing GDS files | Python Code:
from phidl import Device
from phidl import quickplot as qp # Rename "quickplot()" to the easier "qp()"
import phidl.geometry as pg
Explanation: Quick start
PHIDL allows you to create complex designs from simple shapes, and can output the result as GDSII files. The basic element of PHIDL is the Device, which is just a GDS cell with some additional functionality (for those unfamiliar with GDS designs, it can be thought of as a blank area to which you can add polygon shapes). The polygon shapes can also have Ports on them--these allow you to snap shapes together like Lego blocks. You can either hand-design your own polygon shapes, or there is a large library of pre-existing shapes you can use as well.
Brief introduction
This first section is an extremely short tutorial meant to give you an idea of what PHIDL can do. For a more detailed tutorial, please read the following "The basics of PHIDL" section and the other tutorials.
We'll start with some boilerplate imports:
End of explanation
D = Device('mydevice')
Explanation: Then let's create a blank Device (essentially an empty GDS cell with some special features)
End of explanation
xpts = (0,10,10, 0)
ypts = (0, 0, 5, 3)
poly1 = D.add_polygon( [xpts, ypts], layer = 0)
qp(D) # quickplot it!
Explanation: Next let's add a custom polygon using lists of x points and y points. You can also add polygons pair-wise like [(x1,y1), (x2,y2), (x3,y3), ... ]. We'll also image the shape using the handy quickplot() function (imported here as qp())
End of explanation
T = pg.text('Hello!', layer = 1)
A = pg.arc(radius = 25, width = 5, theta = 90, layer = 3)
qp(T) # quickplot it!
qp(A) # quickplot it!
Explanation: You can also create new geometry using the built-in geometry library:
End of explanation
text1 = D.add_ref(T) # Add the text we created as a reference
arc1 = D.add_ref(A) # Add the arc we created
qp(D) # quickplot it!
Explanation: We can easily add these new geometries to D, which currently contains our custom polygon. (For more details about references see below, or the tutorial called "Understanding References".)
End of explanation
text1.movey(5)
text1.movex(-20)
arc1.rotate(-90)
arc1.move([10,22.5])
poly1.ymax = 0
qp(D) # quickplot it!
Explanation: Now that the geometry has been added to D, we can move and rotate everything however we want:
End of explanation
arc2 = D.add_ref(A) # Add a second reference the arc we created earlier
arc2.connect(port = 1, destination = arc1.ports[2])
qp(D) # quickplot it!
Explanation: We can also connect shapes together using their Ports, allowing us to snap shapes together like Legos. Let's add another arc and snap it to the end of the first arc:
End of explanation
import numpy as np
from phidl import quickplot as qp
from phidl import Device
import phidl.geometry as pg
# First we create a blank device `R` (R can be thought of as a blank
# GDS cell with some special features). Note that when we
# make a Device, we usually assign it a variable name with a capital letter
R = Device('rect')
# Next, let's make a list of points representing the points of the rectangle
# for a given width and height
width = 10
height = 3
points = [(0, 0), (width, 0), (width, height), (0, height)]
# Now we turn these points into a polygon shape using add_polygon()
R.add_polygon(points)
# Let's use the built-in "quickplot" function to display the polygon we put in D
qp(R)
Explanation: That's it for the very basics! Keep reading for a more detailed explanation of each of these, or see the other tutorials for topics such as using Groups, creating smooth Paths, and more.
The basics of PHIDL
This is a longer tutorial meant to explain the basics of PHIDL in a little more depth. Further explanation can be found in the other tutorials as well.
PHIDL allows you to create complex designs from simple shapes, and can output the result as GDSII files. The basic element of PHIDL is the Device, which can be thought of as a blank area to which you can add polygon shapes. The polygon shapes can also have Ports on them--these allow you to snap shapes together like Lego blocks. You can either hand-design your own polygon shapes, or there is a large library of pre-existing shapes you can use as well.
Creating a custom shape
Let's start by trying to make a rectangle shape with ports on either end.
End of explanation
# Ports are defined by their width, midpoint, and the direction (orientation) they're facing
# They also must have a name -- this is usually a string or an integer
R.add_port(name = 'myport1', midpoint = [0,height/2], width = height, orientation = 180)
R.add_port(name = 'myport2', midpoint = [width,height/2], width = height, orientation = 0)
# The ports will show up when we quickplot() our shape
qp(R) # quickplot it!
Explanation: Next, let's add Ports to the rectangle which will allow us to connect it to other shapes easily
End of explanation
print(R)
Explanation: We can check to see that our Device has ports in it using the print command:
End of explanation
# Create a new blank Device
E = Device('arc_with_rectangles')
# Also create an arc from the built-in "pg" library
A = pg.arc(width = 3)
# Add a "reference" of the arc to our blank Device
arc_ref = E.add_ref(A)
# Also add two references to our rectangle Device
rect_ref1 = E.add_ref(R)
rect_ref2 = E.add_ref(R)
# Move the shapes around a little
rect_ref1.move([-10,0])
rect_ref2.move([-5,10])
qp(E) # quickplot it!
Explanation: Looks good!
Library & combining shapes
Since this Device is finished, let's create a new (blank) Device and add several shapes to it. Specifically, we will add an arc from the built-in geometry library and two copies of our rectangle Device. We'll then then connect the rectangles to both ends of the arc. The arc() function is contained in the phidl.geometry library which as you can see at the top of this example is imported with the name pg.
This process involves adding "references". These references allow you to create a Device shape once, then reuse it many times in other Devices.
End of explanation
# First, we recall that when we created the references above we saved
# each one its own variable: arc_ref, rect_ref1, and rect_ref2
# We'll use these variables to control/move the reference shapes.
# First, let's move the arc so that it connects to our first rectangle.
# In this command, we tell the arc reference 2 things: (1) what port
# on the arc we want to connect, and (2) where it should go
arc_ref.connect(port = 1, destination = rect_ref1.ports['myport2'])
qp(E) # quickplot it!
# Then we want to move the second rectangle reference so that
# it connects to port 2 of the arc
rect_ref2.connect('myport1', arc_ref.ports[2])
qp(E) # quickplot it!
Explanation: Now we can see we have added 3 shapes to our Device "E": two references to our rectangle Device, and one reference to the arc Device. We can also see that all the references have Ports on them, shown as the labels "myport1", "myport2", "1" and "2".
Next, let's snap everything together like Lego blocks using the connect() command.
End of explanation
print(E)
Explanation: Looks great!
Going a level higher
Now we've made a (somewhat) complicated bend-shape from a few simple shapes. But say we're not done yet -- we actually want to combine together 3 of these bend-shapes to make an even-more complicated shape. We could recreate the geometry 3 times and manually connect all the pieces, but since we already put it together once it will be smarter to just reuse it multiple times.
We will start by abstracting this bend-shape. As shown in the quickplot, there are ports associated with each reference in our bend-shape Device E: "myport1", "myport2", "1", and "2". But when working with this bend-shape, all we really care about is the 2 ports at either end -- "myport1" from rect_ref1 and "myport2" from rect_ref2. It would be simpler if we didn't have to keep track of all of the other ports.
First, let's look at something: let's see if our bend-shape Device E has any ports in it:
End of explanation
# Rather than specifying the midpoint/width/orientation, we can instead
# copy ports directly from the references since they're already in the right place
E.add_port(name = 1, port = rect_ref1.ports['myport1'])
E.add_port(name = 2, port = rect_ref2.ports['myport2'])
qp(E) # quickplot it!
Explanation: It has no ports apparently! Why is that, when we clearly see ports in the quickplots above?
The answer is that Device E itself doesn't have ports -- the references inside E do have ports, but we never actually added ports to E. Let's fix that now, adding a port at either end, setting the names to the integers 1 and 2.
End of explanation
# Create a blank Device
D = Device('triple-bend')
# Add 3 references to our bend-shape Device `E`:
bend_ref1 = D.add_ref(E) # Using the function add_ref()
bend_ref2 = D << E # Using the << operator which is identical to add_ref()
bend_ref3 = D << E
# Let's mirror one of them so it turns right instead of left
bend_ref2.mirror()
# Connect each one in a series
bend_ref2.connect(1, bend_ref1.ports[2])
bend_ref3.connect(1, bend_ref2.ports[2])
# Add ports so we can use this shape at an even higher-level
D.add_port(name = 1, port = bend_ref1.ports[1])
D.add_port(name = 2, port = bend_ref3.ports[2])
qp(D) # quickplot it!
Explanation: If we look at the quickplot above, we can see that there are now red-colored ports on both ends. Ports that are colored red are owned by the Device, ports that are colored blue-green are owned by objects inside the Device. This is good! Now if we want to use this bend-shape, we can interact with its ports named 1 and 2.
Let's go ahead and try to string 3 of these bend-shapes together:
End of explanation
D.write_gds('triple-bend.gds')
Explanation: Saving as a GDSII file
Saving the design as a GDS file is simple -- just specify the Device you'd like to save and run the write_gds() function:
End of explanation
D.write_gds(filename = 'triple-bend.gds', # Output GDS file name
unit = 1e-6, # Base unit (1e-6 = microns)
precision = 1e-9, # Precision / resolution (1e-9 = nanometers)
auto_rename = True, # Automatically rename cells to avoid collisions
max_cellname_length = 28, # Max length of cell names
cellname = 'toplevel' # Name of output top-level cell
)
Explanation: Some useful notes about writing GDS files:
The default unit is 1e-6 (micrometers aka microns), with a precision of 1e-9 (nanometer resolution)
PHIDL will automatically handle naming of all the GDS cells to avoid name-collisions.
Unless otherwise specified, the top-level GDS cell will be named "toplevel"
All of these parameters can be modified using the appropriate arguments of write_gds():
End of explanation |
3,457 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
ACTION REQUIRED to get your credentials
Step1: Run the next cell to set up a connection to your object storage
From the File IO mentu on the right, upload and import the tweets.gz dataset using the DSX UI. Import the dataset to the blank cell below as a SQLContext setup.
Read the tweets as a Spark dataframe and count
Type the following to load the dataframe and time the operation.
t0 = time.time()
tweets = sqlContext.read.json(path_1)
tweets.registerTempTable("tweets")
twr = tweets.count()
print "Number of tweets read
Step2: Investigate Twitter Data Schema
Step3: The keywords
Step4: Use Spark SQL to Filter Relevant Tweets
Step5: Parse Tweets and Remove Stop Words
Step6: Train Word2Vec Model
Word2vec returns a dataframe with words and vectors
Sometimes you need to run this block twice (strange reason that need to de-bug)
Step7: Find top N closest words
Step8: As Expected, Unrelated terms are Not Accurate
Step9: PCA on Top of Word2Vec using DF (spark.ml)
Step10: 3D Visualization
Step11: K-means on top of Word2Vec using DF (spark.ml) | Python Code:
# The code was removed by DSX for sharing.
Explanation: ACTION REQUIRED to get your credentials:
Click on the empty cell below
Then look for the data icon on the top right (drawing with zeros and ones) and click on it
You should see the tweets.gz file, then click on "insert to code and choose the Spark SQLContext option from the drop down options"
You should see a SparkSQL context code block inserted in the cell above with your credentials
Replace the path name to path_1 (if it is not already)
Run the below cell
End of explanation
t0 = time.time()
#datapath = 'swift://'+credentials_1['container']+'.keystone/tweets.gz'
tweets = sqlContext.read.json(path_1)
tweets.registerTempTable("tweets")
twr = tweets.count()
print "Number of tweets read: ", twr
print "Elapsed time (seconds): ", time.time() - t0
Explanation: Run the next cell to set up a connection to your object storage
From the File IO mentu on the right, upload and import the tweets.gz dataset using the DSX UI. Import the dataset to the blank cell below as a SQLContext setup.
Read the tweets as a Spark dataframe and count
Type the following to load the dataframe and time the operation.
t0 = time.time()
tweets = sqlContext.read.json(path_1)
tweets.registerTempTable("tweets")
twr = tweets.count()
print "Number of tweets read: ", twr
print "Elapsed time (seconds): ", time.time() - t0
End of explanation
tweets.printSchema()
Explanation: Investigate Twitter Data Schema
End of explanation
filter = ['santa','claus','merry','christmas','eve',
'congrat','holiday','jingle','bell','silent',
'night','faith','hope','family','new',
'year','spirit','turkey','ham','food']
pd.DataFrame(filter,columns=['word']).head(5)
Explanation: The keywords: christmas, santa, turkey, ...
End of explanation
# Construct SQL Command
t0 = time.time()
sqlString = "("
for substr in filter:
sqlString = sqlString+"text LIKE '%"+substr+"%' OR "
sqlString = sqlString+"text LIKE '%"+substr.upper()+"%' OR "
sqlString=sqlString[:-4]+")"
sqlFilterCommand = "SELECT lang, text FROM tweets WHERE (lang = 'en') AND "+sqlString
# Query tweets in english that contain at least one of the keywords
tweetsDF = sqlContext.sql(sqlFilterCommand).cache()
twf = tweetsDF.count()
print "Number of tweets after filtering: ", twf
# last line add ~9 seconds (from ~0.72 seconds to ~9.42 seconds)
print "Elapsed time (seconds): ", time.time() - t0
print "Percetage of Tweets Used: ", float(twf)/twr
Explanation: Use Spark SQL to Filter Relevant Tweets:
Relevant tweets:
+ In english and
+ Contain at least one of the keywords
End of explanation
tweetsRDD = tweetsDF.select('text').rdd
def parseAndRemoveStopWords(text):
t = text[0].replace(";"," ").replace(":"," ").replace('"',' ').replace('-',' ').replace("?"," ")
t = t.replace(',',' ').replace('.',' ').replace('!','').replace("'"," ").replace("/"," ").replace("\\"," ")
t = t.lower().split(" ")
return t
tw = tweetsRDD.map(parseAndRemoveStopWords)
Explanation: Parse Tweets and Remove Stop Words
End of explanation
# map to df
twDF = tw.map(lambda p: Row(text=p)).toDF()
# default minCount = 5 (we may need to try something larger: 20-100 to reduce cost)
# default vectorSize = 100 (we may want to keep default)
t0 = time.time()
word2Vec = Word2Vec(vectorSize=100, minCount=10, inputCol="text", outputCol="result")
modelW2V = word2Vec.fit(twDF)
wordVectorsDF = modelW2V.getVectors()
print "Elapsed time (seconds) to train Word2Vec: ", time.time() - t0
vocabSize = wordVectorsDF.count()
print "Vocabulary Size: ", vocabSize
Explanation: Train Word2Vec Model
Word2vec returns a dataframe with words and vectors
Sometimes you need to run this block twice (strange reason that need to de-bug)
End of explanation
word = 'christmas'
topN = 5
###
synonymsDF = modelW2V.findSynonyms(word, topN).toPandas()
synonymsDF[['word']].head(topN)
Explanation: Find top N closest words
End of explanation
word = 'dog'
topN = 5
###
synonymsDF = modelW2V.findSynonyms(word, topN).toPandas()
synonymsDF[['word']].head(topN)
Explanation: As Expected, Unrelated terms are Not Accurate
End of explanation
dfW2V = wordVectorsDF.select('vector').withColumnRenamed('vector','features')
numComponents = 3
pca = PCA(k = numComponents, inputCol = 'features', outputCol = 'pcaFeatures')
model = pca.fit(dfW2V)
dfComp = model.transform(dfW2V).select("pcaFeatures")
Explanation: PCA on Top of Word2Vec using DF (spark.ml)
End of explanation
def topNwordsToPlot(dfComp,wordVectorsDF,word,nwords):
compX = np.asarray(dfComp.map(lambda vec: vec[0][0]).collect())
compY = np.asarray(dfComp.map(lambda vec: vec[0][1]).collect())
compZ = np.asarray(dfComp.map(lambda vec: vec[0][2]).collect())
words = np.asarray(wordVectorsDF.select('word').toPandas().values.tolist())
Feat = np.asarray(wordVectorsDF.select('vector').rdd.map(lambda v: np.asarray(v[0])).collect())
Nw = words.shape[0] # total number of words
ind_star = np.where(word == words) # find index associated to 'word'
wstar = Feat[ind_star,:][0][0] # vector associated to 'word'
nwstar = math.sqrt(np.dot(wstar,wstar)) # norm of vector assoicated with 'word'
dist = np.zeros(Nw) # initialize vector of distances
i = 0
for w in Feat: # loop to compute cosine distances between 'word' and the rest of the words
den = math.sqrt(np.dot(w,w))*nwstar # denominator of cosine distance
dist[i] = abs( np.dot(wstar,w) )/den # cosine distance to each word
i = i + 1
indexes = np.argpartition(dist,-(nwords+1))[-(nwords+1):]
di = []
for j in range(nwords+1):
di.append(( words[indexes[j]], dist[indexes[j]], compX[indexes[j]], compY[indexes[j]], compZ[indexes[j]] ) )
result=[]
for elem in sorted(di,key=lambda x: x[1],reverse=True):
result.append((elem[0][0], elem[2], elem[3], elem[4]))
return pd.DataFrame(result,columns=['word','X','Y','Z'])
word = 'christmas'
nwords = 200
#############
r = topNwordsToPlot(dfComp,wordVectorsDF,word,nwords)
############
fs=20 #fontsize
w = r['word']
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
height = 10
width = 10
fig.set_size_inches(width, height)
ax.scatter(r['X'], r['Y'], r['Z'], color='red', s=100, marker='o', edgecolors='black')
for i, txt in enumerate(w):
if(i<2):
ax.text(r['X'].ix[i],r['Y'].ix[i],r['Z'].ix[i], '%s' % (txt), size=30, zorder=1, color='k')
ax.set_xlabel('1st. Component', fontsize=fs)
ax.set_ylabel('2nd. Component', fontsize=fs)
ax.set_zlabel('3rd. Component', fontsize=fs)
ax.set_title('Visualization of Word2Vec via PCA', fontsize=fs)
ax.grid(True)
plt.show()
Explanation: 3D Visualization
End of explanation
t0 = time.time()
K = int(math.floor(math.sqrt(float(vocabSize)/2)))
# K ~ sqrt(n/2) this is a rule of thumb for choosing K,
# where n is the number of words in the model
# feel free to choose K with a fancier algorithm
dfW2V = wordVectorsDF.select('vector').withColumnRenamed('vector','features')
kmeans = KMeans(k=K, seed=1)
modelK = kmeans.fit(dfW2V)
labelsDF = modelK.transform(dfW2V).select('prediction').withColumnRenamed('prediction','labels')
print "Number of Clusters (K) Used: ", K
print "Elapsed time (seconds) :", time.time() - t0
Explanation: K-means on top of Word2Vec using DF (spark.ml)
End of explanation |
3,458 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Step1: Language Translation
In this project, you’re going to take a peek into the realm of neural network machine translation. You’ll be training a sequence to sequence model on a dataset of English and French sentences that can translate new sentences from English to French.
Get the Data
Since translating the whole language of English to French will take lots of time to train, we have provided you with a small portion of the English corpus.
Step3: Explore the Data
Play around with view_sentence_range to view different parts of the data.
Step6: Implement Preprocessing Function
Text to Word Ids
As you did with other RNNs, you must turn the text into a number so the computer can understand it. In the function text_to_ids(), you'll turn source_text and target_text from words to ids. However, you need to add the <EOS> word id at the end of each sentence from target_text. This will help the neural network predict when the sentence should end.
You can get the <EOS> word id by doing
Step8: Preprocess all the data and save it
Running the code cell below will preprocess all the data and save it to file.
Step10: Check Point
This is your first checkpoint. If you ever decide to come back to this notebook or have to restart the notebook, you can start from here. The preprocessed data has been saved to disk.
Step12: Check the Version of TensorFlow and Access to GPU
This will check to make sure you have the correct version of TensorFlow and access to a GPU
Step15: Build the Neural Network
You'll build the components necessary to build a Sequence-to-Sequence model by implementing the following functions below
Step18: Process Decoding Input
Implement process_decoding_input using TensorFlow to remove the last word id from each batch in target_data and concat the GO ID to the begining of each batch.
Step21: Encoding
Implement encoding_layer() to create a Encoder RNN layer using tf.nn.dynamic_rnn().
Step24: Decoding - Training
Create training logits using tf.contrib.seq2seq.simple_decoder_fn_train() and tf.contrib.seq2seq.dynamic_rnn_decoder(). Apply the output_fn to the tf.contrib.seq2seq.dynamic_rnn_decoder() outputs.
Step27: Decoding - Inference
Create inference logits using tf.contrib.seq2seq.simple_decoder_fn_inference() and tf.contrib.seq2seq.dynamic_rnn_decoder().
Step30: Build the Decoding Layer
Implement decoding_layer() to create a Decoder RNN layer.
Create RNN cell for decoding using rnn_size and num_layers.
Create the output fuction using lambda to transform it's input, logits, to class logits.
Use the your decoding_layer_train(encoder_state, dec_cell, dec_embed_input, sequence_length, decoding_scope, output_fn, keep_prob) function to get the training logits.
Use your decoding_layer_infer(encoder_state, dec_cell, dec_embeddings, start_of_sequence_id, end_of_sequence_id, maximum_length, vocab_size, decoding_scope, output_fn, keep_prob) function to get the inference logits.
Note
Step33: Build the Neural Network
Apply the functions you implemented above to
Step34: Neural Network Training
Hyperparameters
Tune the following parameters
Step36: Build the Graph
Build the graph using the neural network you implemented.
Step39: Train
Train the neural network on the preprocessed data. If you have a hard time getting a good loss, check the forums to see if anyone is having the same problem.
Step41: Save Parameters
Save the batch_size and save_path parameters for inference.
Step43: Checkpoint
Step46: Sentence to Sequence
To feed a sentence into the model for translation, you first need to preprocess it. Implement the function sentence_to_seq() to preprocess new sentences.
Convert the sentence to lowercase
Convert words into ids using vocab_to_int
Convert words not in the vocabulary, to the <UNK> word id.
Step48: Translate
This will translate translate_sentence from English to French. | Python Code:
DON'T MODIFY ANYTHING IN THIS CELL
import helper
import problem_unittests as tests
source_path = 'data/small_vocab_en'
target_path = 'data/small_vocab_fr'
source_text = helper.load_data(source_path)
target_text = helper.load_data(target_path)
Explanation: Language Translation
In this project, you’re going to take a peek into the realm of neural network machine translation. You’ll be training a sequence to sequence model on a dataset of English and French sentences that can translate new sentences from English to French.
Get the Data
Since translating the whole language of English to French will take lots of time to train, we have provided you with a small portion of the English corpus.
End of explanation
view_sentence_range = (0, 10)
DON'T MODIFY ANYTHING IN THIS CELL
import numpy as np
print('Dataset Stats')
print('Roughly the number of unique words: {}'.format(len({word: None for word in source_text.split()})))
sentences = source_text.split('\n')
word_counts = [len(sentence.split()) for sentence in sentences]
print('Number of sentences: {}'.format(len(sentences)))
print('Average number of words in a sentence: {}'.format(np.average(word_counts)))
print()
print('English sentences {} to {}:'.format(*view_sentence_range))
print('\n'.join(source_text.split('\n')[view_sentence_range[0]:view_sentence_range[1]]))
print()
print('French sentences {} to {}:'.format(*view_sentence_range))
print('\n'.join(target_text.split('\n')[view_sentence_range[0]:view_sentence_range[1]]))
Explanation: Explore the Data
Play around with view_sentence_range to view different parts of the data.
End of explanation
def text_to_ids(source_text, target_text, source_vocab_to_int, target_vocab_to_int):
Convert source and target text to proper word ids
:param source_text: String that contains all the source text.
:param target_text: String that contains all the target text.
:param source_vocab_to_int: Dictionary to go from the source words to an id
:param target_vocab_to_int: Dictionary to go from the target words to an id
:return: A tuple of lists (source_id_text, target_id_text)
# TODO: Implement Function
target_text_eos = [line+' <EOS>' for line in target_text.split('\n')]
source_id_text = [[source_vocab_to_int[word] for word in line.split()] for line in source_text.split('\n')]
target_id_text = [[target_vocab_to_int[word] for word in line.split()] for line in target_text_eos]
return source_id_text, target_id_text
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_text_to_ids(text_to_ids)
Explanation: Implement Preprocessing Function
Text to Word Ids
As you did with other RNNs, you must turn the text into a number so the computer can understand it. In the function text_to_ids(), you'll turn source_text and target_text from words to ids. However, you need to add the <EOS> word id at the end of each sentence from target_text. This will help the neural network predict when the sentence should end.
You can get the <EOS> word id by doing:
python
target_vocab_to_int['<EOS>']
You can get other word ids using source_vocab_to_int and target_vocab_to_int.
End of explanation
DON'T MODIFY ANYTHING IN THIS CELL
helper.preprocess_and_save_data(source_path, target_path, text_to_ids)
Explanation: Preprocess all the data and save it
Running the code cell below will preprocess all the data and save it to file.
End of explanation
DON'T MODIFY ANYTHING IN THIS CELL
import numpy as np
import helper
(source_int_text, target_int_text), (source_vocab_to_int, target_vocab_to_int), _ = helper.load_preprocess()
Explanation: Check Point
This is your first checkpoint. If you ever decide to come back to this notebook or have to restart the notebook, you can start from here. The preprocessed data has been saved to disk.
End of explanation
DON'T MODIFY ANYTHING IN THIS CELL
from distutils.version import LooseVersion
import warnings
import tensorflow as tf
# Check TensorFlow Version
assert LooseVersion(tf.__version__) in [LooseVersion('1.0.0'), LooseVersion('1.0.1')], 'This project requires TensorFlow version 1.0 You are using {}'.format(tf.__version__)
print('TensorFlow Version: {}'.format(tf.__version__))
# Check for a GPU
if not tf.test.gpu_device_name():
warnings.warn('No GPU found. Please use a GPU to train your neural network.')
else:
print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))
Explanation: Check the Version of TensorFlow and Access to GPU
This will check to make sure you have the correct version of TensorFlow and access to a GPU
End of explanation
def model_inputs():
Create TF Placeholders for input, targets, and learning rate.
:return: Tuple (input, targets, learning rate, keep probability)
# TODO: Implement Function
inputs = tf.placeholder(dtype=tf.int32, shape=[None, None], name='input')
targets = tf.placeholder(dtype=tf.int32, shape=[None, None], name='target')
lr = tf.placeholder(dtype=tf.float32, name='learning_rate')
keep_prob = tf.placeholder(dtype=tf.float32, name='keep_prob')
return inputs, targets, lr, keep_prob
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_model_inputs(model_inputs)
Explanation: Build the Neural Network
You'll build the components necessary to build a Sequence-to-Sequence model by implementing the following functions below:
- model_inputs
- process_decoding_input
- encoding_layer
- decoding_layer_train
- decoding_layer_infer
- decoding_layer
- seq2seq_model
Input
Implement the model_inputs() function to create TF Placeholders for the Neural Network. It should create the following placeholders:
Input text placeholder named "input" using the TF Placeholder name parameter with rank 2.
Targets placeholder with rank 2.
Learning rate placeholder with rank 0.
Keep probability placeholder named "keep_prob" using the TF Placeholder name parameter with rank 0.
Return the placeholders in the following the tuple (Input, Targets, Learing Rate, Keep Probability)
End of explanation
def process_decoding_input(target_data, target_vocab_to_int, batch_size):
Preprocess target data for decoding
:param target_data: Target Placeholder
:param target_vocab_to_int: Dictionary to go from the target words to an id
:param batch_size: Batch Size
:return: Preprocessed target data
# TODO: Implement Function
ending = tf.strided_slice(target_data, [0, 0], [batch_size, -1], [1, 1])
target_data = tf.concat([tf.fill([batch_size, 1], target_vocab_to_int['<GO>']), ending], axis=1)
return target_data
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_process_decoding_input(process_decoding_input)
Explanation: Process Decoding Input
Implement process_decoding_input using TensorFlow to remove the last word id from each batch in target_data and concat the GO ID to the begining of each batch.
End of explanation
def encoding_layer(rnn_inputs, rnn_size, num_layers, keep_prob):
Create encoding layer
:param rnn_inputs: Inputs for the RNN
:param rnn_size: RNN Size
:param num_layers: Number of layers
:param keep_prob: Dropout keep probability
:return: RNN state
# TODO: Implement Function
lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)
lstm_dropout = tf.contrib.rnn.DropoutWrapper(lstm, input_keep_prob=keep_prob)
cell = tf.contrib.rnn.MultiRNNCell([lstm_dropout]*num_layers)
_, state = tf.nn.dynamic_rnn(cell, rnn_inputs, dtype=tf.float32)
return state
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_encoding_layer(encoding_layer)
Explanation: Encoding
Implement encoding_layer() to create a Encoder RNN layer using tf.nn.dynamic_rnn().
End of explanation
def decoding_layer_train(encoder_state, dec_cell, dec_embed_input, sequence_length, decoding_scope,
output_fn, keep_prob):
Create a decoding layer for training
:param encoder_state: Encoder State
:param dec_cell: Decoder RNN Cell
:param dec_embed_input: Decoder embedded input
:param sequence_length: Sequence Length
:param decoding_scope: TenorFlow Variable Scope for decoding
:param output_fn: Function to apply the output layer
:param keep_prob: Dropout keep probability
:return: Train Logits
# TODO: Implement Function
train_decoder_fn = tf.contrib.seq2seq.simple_decoder_fn_train(encoder_state)
train_pred,_,_ = tf.contrib.seq2seq.dynamic_rnn_decoder(
dec_cell, train_decoder_fn, dec_embed_input, sequence_length, scope=decoding_scope)
train_logits = output_fn(tf.nn.dropout(train_pred, keep_prob))
#logits = tf.nn.dropout(train_logits, keep_prob)
return train_logits
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_decoding_layer_train(decoding_layer_train)
Explanation: Decoding - Training
Create training logits using tf.contrib.seq2seq.simple_decoder_fn_train() and tf.contrib.seq2seq.dynamic_rnn_decoder(). Apply the output_fn to the tf.contrib.seq2seq.dynamic_rnn_decoder() outputs.
End of explanation
def decoding_layer_infer(encoder_state, dec_cell, dec_embeddings, start_of_sequence_id, end_of_sequence_id,
maximum_length, vocab_size, decoding_scope, output_fn, keep_prob):
Create a decoding layer for inference
:param encoder_state: Encoder state
:param dec_cell: Decoder RNN Cell
:param dec_embeddings: Decoder embeddings
:param start_of_sequence_id: GO ID
:param end_of_sequence_id: EOS Id
:param maximum_length: The maximum allowed time steps to decode
:param vocab_size: Size of vocabulary
:param decoding_scope: TensorFlow Variable Scope for decoding
:param output_fn: Function to apply the output layer
:param keep_prob: Dropout keep probability
:return: Inference Logits
# TODO: Implement Function
infer_decoder_fn = tf.contrib.seq2seq.simple_decoder_fn_inference(
output_fn, encoder_state, dec_embeddings, start_of_sequence_id, end_of_sequence_id, maximum_length, vocab_size)
infer_logits,_,_ = tf.contrib.seq2seq.dynamic_rnn_decoder(
dec_cell, infer_decoder_fn, scope=decoding_scope)
return infer_logits
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_decoding_layer_infer(decoding_layer_infer)
Explanation: Decoding - Inference
Create inference logits using tf.contrib.seq2seq.simple_decoder_fn_inference() and tf.contrib.seq2seq.dynamic_rnn_decoder().
End of explanation
def decoding_layer(dec_embed_input, dec_embeddings, encoder_state, vocab_size, sequence_length, rnn_size,
num_layers, target_vocab_to_int, keep_prob):
Create decoding layer
:param dec_embed_input: Decoder embedded input
:param dec_embeddings: Decoder embeddings
:param encoder_state: The encoded state
:param vocab_size: Size of vocabulary
:param sequence_length: Sequence Length
:param rnn_size: RNN Size
:param num_layers: Number of layers
:param target_vocab_to_int: Dictionary to go from the target words to an id
:param keep_prob: Dropout keep probability
:return: Tuple of (Training Logits, Inference Logits)
# TODO: Implement Function
lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)
lstm_dropout = tf.contrib.rnn.DropoutWrapper(lstm, keep_prob)
cell = tf.contrib.rnn.MultiRNNCell([lstm_dropout]*num_layers)
with tf.variable_scope("decoding") as decoding_scope:
output_fn = lambda x: tf.contrib.layers.fully_connected(x, vocab_size, None, scope=decoding_scope)
train_logits = decoding_layer_train(encoder_state, cell, dec_embed_input, sequence_length, decoding_scope,
output_fn, keep_prob)
with tf.variable_scope("decoding", reuse=True) as decoding_scope:
infer_logits = decoding_layer_infer(encoder_state, cell, dec_embeddings, target_vocab_to_int['<GO>'],
target_vocab_to_int['<EOS>'], sequence_length-1, vocab_size,
decoding_scope, output_fn, keep_prob)
return train_logits, infer_logits
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_decoding_layer(decoding_layer)
Explanation: Build the Decoding Layer
Implement decoding_layer() to create a Decoder RNN layer.
Create RNN cell for decoding using rnn_size and num_layers.
Create the output fuction using lambda to transform it's input, logits, to class logits.
Use the your decoding_layer_train(encoder_state, dec_cell, dec_embed_input, sequence_length, decoding_scope, output_fn, keep_prob) function to get the training logits.
Use your decoding_layer_infer(encoder_state, dec_cell, dec_embeddings, start_of_sequence_id, end_of_sequence_id, maximum_length, vocab_size, decoding_scope, output_fn, keep_prob) function to get the inference logits.
Note: You'll need to use tf.variable_scope to share variables between training and inference.
End of explanation
def seq2seq_model(input_data, target_data, keep_prob, batch_size, sequence_length, source_vocab_size, target_vocab_size,
enc_embedding_size, dec_embedding_size, rnn_size, num_layers, target_vocab_to_int):
Build the Sequence-to-Sequence part of the neural network
:param input_data: Input placeholder
:param target_data: Target placeholder
:param keep_prob: Dropout keep probability placeholder
:param batch_size: Batch Size
:param sequence_length: Sequence Length
:param source_vocab_size: Source vocabulary size
:param target_vocab_size: Target vocabulary size
:param enc_embedding_size: Decoder embedding size
:param dec_embedding_size: Encoder embedding size
:param rnn_size: RNN Size
:param num_layers: Number of layers
:param target_vocab_to_int: Dictionary to go from the target words to an id
:return: Tuple of (Training Logits, Inference Logits)
# TODO: Implement Function
enc_embed_input = tf.contrib.layers.embed_sequence(input_data, source_vocab_size, enc_embedding_size)
enc_state = encoding_layer(enc_embed_input, rnn_size, num_layers, keep_prob)
dec_input = process_decoding_input(target_data, target_vocab_to_int, batch_size)
dec_embeddings = tf.Variable(tf.random_uniform([target_vocab_size, dec_embedding_size]))
dec_embed_input = tf.nn.embedding_lookup(dec_embeddings, dec_input)
train_logits, infer_logits = decoding_layer(dec_embed_input, dec_embeddings, enc_state, target_vocab_size,
sequence_length, rnn_size, num_layers, target_vocab_to_int, keep_prob)
return train_logits, infer_logits
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_seq2seq_model(seq2seq_model)
Explanation: Build the Neural Network
Apply the functions you implemented above to:
Apply embedding to the input data for the encoder.
Encode the input using your encoding_layer(rnn_inputs, rnn_size, num_layers, keep_prob).
Process target data using your process_decoding_input(target_data, target_vocab_to_int, batch_size) function.
Apply embedding to the target data for the decoder.
Decode the encoded input using your decoding_layer(dec_embed_input, dec_embeddings, encoder_state, vocab_size, sequence_length, rnn_size, num_layers, target_vocab_to_int, keep_prob).
End of explanation
# Number of Epochs
epochs = 15
# Batch Size
batch_size = 512
# RNN Size
rnn_size = 256
# Number of Layers
num_layers = 2
# Embedding Size
encoding_embedding_size = 128
decoding_embedding_size = 128
# Learning Rate
learning_rate = 0.001
# Dropout Keep Probability
keep_probability = 0.8
Explanation: Neural Network Training
Hyperparameters
Tune the following parameters:
Set epochs to the number of epochs.
Set batch_size to the batch size.
Set rnn_size to the size of the RNNs.
Set num_layers to the number of layers.
Set encoding_embedding_size to the size of the embedding for the encoder.
Set decoding_embedding_size to the size of the embedding for the decoder.
Set learning_rate to the learning rate.
Set keep_probability to the Dropout keep probability
End of explanation
DON'T MODIFY ANYTHING IN THIS CELL
save_path = 'checkpoints/dev'
(source_int_text, target_int_text), (source_vocab_to_int, target_vocab_to_int), _ = helper.load_preprocess()
max_source_sentence_length = max([len(sentence) for sentence in source_int_text])
train_graph = tf.Graph()
with train_graph.as_default():
input_data, targets, lr, keep_prob = model_inputs()
sequence_length = tf.placeholder_with_default(max_source_sentence_length, None, name='sequence_length')
input_shape = tf.shape(input_data)
train_logits, inference_logits = seq2seq_model(
tf.reverse(input_data, [-1]), targets, keep_prob, batch_size, sequence_length, len(source_vocab_to_int), len(target_vocab_to_int),
encoding_embedding_size, decoding_embedding_size, rnn_size, num_layers, target_vocab_to_int)
tf.identity(inference_logits, 'logits')
with tf.name_scope("optimization"):
# Loss function
cost = tf.contrib.seq2seq.sequence_loss(
train_logits,
targets,
tf.ones([input_shape[0], sequence_length]))
# Optimizer
optimizer = tf.train.AdamOptimizer(lr)
# Gradient Clipping
gradients = optimizer.compute_gradients(cost)
capped_gradients = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in gradients if grad is not None]
train_op = optimizer.apply_gradients(capped_gradients)
Explanation: Build the Graph
Build the graph using the neural network you implemented.
End of explanation
DON'T MODIFY ANYTHING IN THIS CELL
import time
def get_accuracy(target, logits):
Calculate accuracy
max_seq = max(target.shape[1], logits.shape[1])
if max_seq - target.shape[1]:
target = np.pad(
target,
[(0,0),(0,max_seq - target.shape[1])],
'constant')
if max_seq - logits.shape[1]:
logits = np.pad(
logits,
[(0,0),(0,max_seq - logits.shape[1]), (0,0)],
'constant')
return np.mean(np.equal(target, np.argmax(logits, 2)))
train_source = source_int_text[batch_size:]
train_target = target_int_text[batch_size:]
valid_source = helper.pad_sentence_batch(source_int_text[:batch_size])
valid_target = helper.pad_sentence_batch(target_int_text[:batch_size])
with tf.Session(graph=train_graph) as sess:
sess.run(tf.global_variables_initializer())
for epoch_i in range(epochs):
for batch_i, (source_batch, target_batch) in enumerate(
helper.batch_data(train_source, train_target, batch_size)):
start_time = time.time()
_, loss = sess.run(
[train_op, cost],
{input_data: source_batch,
targets: target_batch,
lr: learning_rate,
sequence_length: target_batch.shape[1],
keep_prob: keep_probability})
batch_train_logits = sess.run(
inference_logits,
{input_data: source_batch, keep_prob: 1.0})
batch_valid_logits = sess.run(
inference_logits,
{input_data: valid_source, keep_prob: 1.0})
train_acc = get_accuracy(target_batch, batch_train_logits)
valid_acc = get_accuracy(np.array(valid_target), batch_valid_logits)
end_time = time.time()
print('Epoch {:>3} Batch {:>4}/{} - Train Accuracy: {:>6.3f}, Validation Accuracy: {:>6.3f}, Loss: {:>6.3f}'
.format(epoch_i, batch_i, len(source_int_text) // batch_size, train_acc, valid_acc, loss))
# Save Model
saver = tf.train.Saver()
saver.save(sess, save_path)
print('Model Trained and Saved')
Explanation: Train
Train the neural network on the preprocessed data. If you have a hard time getting a good loss, check the forums to see if anyone is having the same problem.
End of explanation
DON'T MODIFY ANYTHING IN THIS CELL
# Save parameters for checkpoint
helper.save_params(save_path)
Explanation: Save Parameters
Save the batch_size and save_path parameters for inference.
End of explanation
DON'T MODIFY ANYTHING IN THIS CELL
import tensorflow as tf
import numpy as np
import helper
import problem_unittests as tests
_, (source_vocab_to_int, target_vocab_to_int), (source_int_to_vocab, target_int_to_vocab) = helper.load_preprocess()
load_path = helper.load_params()
Explanation: Checkpoint
End of explanation
def sentence_to_seq(sentence, vocab_to_int):
Convert a sentence to a sequence of ids
:param sentence: String
:param vocab_to_int: Dictionary to go from the words to an id
:return: List of word ids
# TODO: Implement Function
ids = [vocab_to_int.get(word, vocab_to_int['<UNK>']) for word in sentence.lower().split()]
return ids
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
tests.test_sentence_to_seq(sentence_to_seq)
Explanation: Sentence to Sequence
To feed a sentence into the model for translation, you first need to preprocess it. Implement the function sentence_to_seq() to preprocess new sentences.
Convert the sentence to lowercase
Convert words into ids using vocab_to_int
Convert words not in the vocabulary, to the <UNK> word id.
End of explanation
translate_sentence = 'he saw a old yellow truck .'
DON'T MODIFY ANYTHING IN THIS CELL
translate_sentence = sentence_to_seq(translate_sentence, source_vocab_to_int)
loaded_graph = tf.Graph()
with tf.Session(graph=loaded_graph) as sess:
# Load saved model
loader = tf.train.import_meta_graph(load_path + '.meta')
loader.restore(sess, load_path)
input_data = loaded_graph.get_tensor_by_name('input:0')
logits = loaded_graph.get_tensor_by_name('logits:0')
keep_prob = loaded_graph.get_tensor_by_name('keep_prob:0')
translate_logits = sess.run(logits, {input_data: [translate_sentence], keep_prob: 1.0})[0]
print('Input')
print(' Word Ids: {}'.format([i for i in translate_sentence]))
print(' English Words: {}'.format([source_int_to_vocab[i] for i in translate_sentence]))
print('\nPrediction')
print(' Word Ids: {}'.format([i for i in np.argmax(translate_logits, 1)]))
print(' French Words: {}'.format([target_int_to_vocab[i] for i in np.argmax(translate_logits, 1)]))
Explanation: Translate
This will translate translate_sentence from English to French.
End of explanation |
3,459 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
数据清洗之推特数据
王成军
[email protected]
计算传播网 http
Step1: Lazy Method for Reading Big File in Python?
Step2: 字节（Byte /bait/）
计算机信息技术用于计量存储容量的一种计量单位，通常情况下一字节等于有八位， [1] 也表示一些计算机编程语言中的数据类型和语言字符。
- 1B（byte，字节）= 8 bit；
- 1KB=1000B；1MB=1000KB=1000×1000B。其中1000=10^3。
- 1KB（kilobyte，千字节）=1000B= 10^3 B；
- 1MB（Megabyte，兆字节，百万字节，简称“兆”）=1000KB= 10^6 B；
- 1GB（Gigabyte，吉字节，十亿字节，又称“千兆”）=1000MB= 10^9 B；
用Pandas的get_chunk功能来处理亿级数据
只有在超过5TB数据量的规模下，Hadoop才是一个合理的技术选择。
Step3: 2. 清洗错行的情况
Step4: 问题： 第一行是变量名
1. 如何去掉换行符？
2. 如何获取每一个变量名？
Step5: 如何来处理错误换行情况？
Step6: 同时考虑分列符和引用符
分列符🔥分隔符：sep, delimiter
引用符☁️：quotechar
Step7: 3. 读取数据、正确分列
Step8: 4. 统计数量
统计发帖数量所对应的人数的分布
人数在发帖数量方面的分布情况
Step9: 安装微软雅黑字体
为了在绘图时正确显示中文，需要安装/data/文件夹中的微软雅黑字体（msyh.ttf）
详见common questions
Step10: 5. 清洗tweets文本
Step11: 安装twitter_text
twitter-text-py could not be used for python 3
<del>pip install twitter-text</del>
Glyph debug the problem, and make a new repo of twitter-text-py3.
pip install twitter-text
无法正常安装的同学
可以在spyder中打开terminal安装
pip install twitter-text
Step12: 获得清洗过的推特文本
不含人名、url、各种符号（如RT @等） | Python Code:
bigfile = open('/Users/chengjun/百度云同步盘/Writing/OWS/ows-raw.txt', 'r')
chunkSize = 1000000
chunk = bigfile.readlines(chunkSize)
print(len(chunk))
with open("/Users/chengjun/GitHub/cjc/data/ows_tweets_sample.txt", 'w') as f:
for i in chunk:
f.write(i)
Explanation: 数据清洗之推特数据
王成军
[email protected]
计算传播网 http://computational-communication.com
数据清洗（data cleaning）
是数据分析的重要步骤，其主要目标是将混杂的数据清洗为可以被直接分析的数据，一般需要将数据转化为数据框（data frame）的样式。
本章将以推特文本的清洗作为例子，介绍数据清洗的基本逻辑。
清洗错误行
正确分列
提取所要分析的内容
介绍通过按行、chunk的方式对大规模数据进行预处理
1. 抽取tweets样本做实验
此节学生略过
End of explanation
# https://stackoverflow.com/questions/519633/lazy-method-for-reading-big-file-in-python?lq=1
import csv
bigfile = open('/Users/datalab/bigdata/cjc/ows-raw.txt', 'r')
chunkSize = 10**8
chunk = bigfile.readlines(chunkSize)
num, num_lines = 0, 0
while chunk:
lines = csv.reader((line.replace('\x00','') for line in chunk),
delimiter=',', quotechar='"')
#do sth.
num_lines += len(list(lines))
print(num, num_lines)
num += 1
chunk = bigfile.readlines(chunkSize) # read another chunk
Explanation: Lazy Method for Reading Big File in Python?
End of explanation
import pandas as pd
f = open('../bigdata/OWS/ows-raw.txt',encoding='utf-8')
reader = pd.read_table(f, sep=',', iterator=True, error_bad_lines=False) #跳过报错行
loop = True
chunkSize = 100000
data = []
while loop:
try:
chunk = reader.get_chunk(chunkSize)
dat = data_cleaning_funtion(chunk) # do sth.
data.append(dat)
except StopIteration:
loop = False
print("Iteration is stopped.")
df = pd.concat(data, ignore_index=True)
Explanation: 字节（Byte /bait/）
计算机信息技术用于计量存储容量的一种计量单位，通常情况下一字节等于有八位， [1] 也表示一些计算机编程语言中的数据类型和语言字符。
- 1B（byte，字节）= 8 bit；
- 1KB=1000B；1MB=1000KB=1000×1000B。其中1000=10^3。
- 1KB（kilobyte，千字节）=1000B= 10^3 B；
- 1MB（Megabyte，兆字节，百万字节，简称“兆”）=1000KB= 10^6 B；
- 1GB（Gigabyte，吉字节，十亿字节，又称“千兆”）=1000MB= 10^9 B；
用Pandas的get_chunk功能来处理亿级数据
只有在超过5TB数据量的规模下，Hadoop才是一个合理的技术选择。
End of explanation
with open("../data/ows_tweets_sample.txt", 'r') as f:
lines = f.readlines()
# 总行数
len(lines)
# 查看第一行
lines[15]
help(lines[1].split)
Explanation: 2. 清洗错行的情况
End of explanation
varNames = lines[0].replace('\n', '').split(',')
varNames
len(varNames)
lines[1344]
Explanation: 问题： 第一行是变量名
1. 如何去掉换行符？
2. 如何获取每一个变量名？
End of explanation
with open("../data/ows_tweets_sample_clean.txt", 'w') as f:
right_line = '' # 正确的行，它是一个空字符串
blocks = [] # 确认为正确的行会被添加到blocks里面
for line in lines:
right_line += line.replace('\n', ' ')
line_length = len(right_line.split(','))
if line_length >= 14:
blocks.append(right_line)
right_line = ''
for i in blocks:
f.write(i + '\n')
len(blocks)
blocks[1344]
Explanation: 如何来处理错误换行情况？
End of explanation
import re
re.split(',"|",', lines[15])
import re
with open("../data/ows_tweets_sample.txt",'r') as f:
lines = f.readlines()
for i in range(35,50):
i_ = re.split(',"|",', lines[i])
print('line =',i,' length =', len(i_))
with open("../data/ows_tweets_sample_clean4.txt", 'w') as f:
right_line = '' # 正确的行，它是一个空字符串
blocks = [] # 确认为正确的行会被添加到blocks里面
for line in lines:
right_line += line.replace('\n', ' ').replace('\r', ' ')
#line_length = len(right_line.split(','))
i_ = re.split(',"|",', right_line)
line_length = len(i_)
if line_length >= 6:
blocks.append(right_line)
right_line = ''
# for i in blocks:
# f.write(i + '\n')
len(blocks)
Explanation: 同时考虑分列符和引用符
分列符🔥分隔符：sep, delimiter
引用符☁️：quotechar
End of explanation
# 提示：你可能需要修改以下路径名
with open("../data/ows_tweets_sample.txt", 'r') as f:
chunk = f.readlines()
len(chunk)
chunk[:3]
import csv
lines_csv = csv.reader(chunk, delimiter=',', quotechar='"')
print(len(list(lines_csv)))
# next(lines_csv)
# next(lines_csv)
import re
import csv
from collections import defaultdict
def extract_rt_user(tweet):
rt_patterns = re.compile(r"(RT|via)((?:\b\W*@\w+)+)", re.IGNORECASE)
rt_user_name = rt_patterns.findall(tweet)
if rt_user_name:
rt_user_name = rt_user_name[0][1].strip(' @')
else:
rt_user_name = None
return rt_user_name
rt_network = defaultdict(int)
f = open("../data/ows_tweets_sample.txt", 'r')
chunk = f.readlines(100000)
while chunk:
#lines = csv.reader(chunk, delimiter=',', quotechar='"')
lines = csv.reader((line.replace('\x00','') for line in chunk), delimiter=',', quotechar='"')
for line in lines:
tweet = line[1]
from_user = line[8]
rt_user = extract_rt_user(tweet)
rt_network[(from_user, rt_user)] += 1
chunk = f.readlines(100000)
import pandas as pd
df = pd.read_csv("../data/ows_tweets_sample.txt",
sep = ',', quotechar='"')
df[:3]
len(df)
df.Text[0]
df['From User'][:10]
Explanation: 3. 读取数据、正确分列
End of explanation
from collections import defaultdict
data_dict = defaultdict(int)
for i in df['From User']:
data_dict[i] +=1
list(data_dict.items())[:5]
#data_dict
%matplotlib inline
import matplotlib.pyplot as plt
Explanation: 4. 统计数量
统计发帖数量所对应的人数的分布
人数在发帖数量方面的分布情况
End of explanation
plt.hist(data_dict.values())
#plt.yscale('log')
#plt.xscale('log')
plt.xlabel(u'发帖数', fontsize = 20)
plt.ylabel(u'人数', fontsize = 20)
plt.show()
tweet_dict = defaultdict(int)
for i in data_dict.values():
tweet_dict[i] += 1
plt.loglog(tweet_dict.keys(), tweet_dict.values(), 'ro')#linewidth=2)
plt.xlabel(u'推特数', fontsize=20)
plt.ylabel(u'人数', fontsize=20 )
plt.show()
import numpy as np
import statsmodels.api as sm
def powerPlot(d_value, d_freq, color, marker):
d_freq = [i + 1 for i in d_freq]
d_prob = [float(i)/sum(d_freq) for i in d_freq]
#d_rank = ss.rankdata(d_value).astype(int)
x = np.log(d_value)
y = np.log(d_prob)
xx = sm.add_constant(x, prepend=True)
res = sm.OLS(y,xx).fit()
constant,beta = res.params
r2 = res.rsquared
plt.plot(d_value, d_prob, linestyle = '',\
color = color, marker = marker)
plt.plot(d_value, np.exp(constant+x*beta),"red")
plt.xscale('log'); plt.yscale('log')
plt.text(max(d_value)/2,max(d_prob)/10,
r'$\beta$ = ' + str(round(beta,2)) +'\n' + r'$R^2$ = ' + str(round(r2, 2)), fontsize = 20)
histo, bin_edges = np.histogram(list(data_dict.values()), 15)
bin_center = 0.5*(bin_edges[1:] + bin_edges[:-1])
powerPlot(bin_center,histo, 'r', '^')
#lg=plt.legend(labels = [u'Tweets', u'Fit'], loc=3, fontsize=20)
plt.ylabel(u'概率', fontsize=20)
plt.xlabel(u'推特数', fontsize=20)
plt.show()
import statsmodels.api as sm
from collections import defaultdict
import numpy as np
def powerPlot2(data):
d = sorted(data, reverse = True )
d_table = defaultdict(int)
for k in d:
d_table[k] += 1
d_value = sorted(d_table)
d_value = [i+1 for i in d_value]
d_freq = [d_table[i]+1 for i in d_value]
d_prob = [float(i)/sum(d_freq) for i in d_freq]
x = np.log(d_value)
y = np.log(d_prob)
xx = sm.add_constant(x, prepend=True)
res = sm.OLS(y,xx).fit()
constant,beta = res.params
r2 = res.rsquared
plt.plot(d_value, d_prob, 'ro')
plt.plot(d_value, np.exp(constant+x*beta),"red")
plt.xscale('log'); plt.yscale('log')
plt.text(max(d_value)/2,max(d_prob)/5,
'Beta = ' + str(round(beta,2)) +'\n' + 'R squared = ' + str(round(r2, 2)))
plt.title('Distribution')
plt.ylabel('P(K)')
plt.xlabel('K')
plt.show()
powerPlot2(data_dict.values())
import powerlaw
def plotPowerlaw(data,ax,col,xlab):
fit = powerlaw.Fit(data,xmin=2)
#fit = powerlaw.Fit(data)
fit.plot_pdf(color = col, linewidth = 2)
a,x = (fit.power_law.alpha,fit.power_law.xmin)
fit.power_law.plot_pdf(color = col, linestyle = 'dotted', ax = ax, \
label = r"$\alpha = %d \:\:, x_{min} = %d$" % (a,x))
ax.set_xlabel(xlab, fontsize = 20)
ax.set_ylabel('$Probability$', fontsize = 20)
plt.legend(loc = 0, frameon = False)
from collections import defaultdict
data_dict = defaultdict(int)
for i in df['From User']:
data_dict[i] += 1
import matplotlib.cm as cm
cmap = cm.get_cmap('rainbow_r',6)
fig = plt.figure(figsize=(6, 4),facecolor='white')
ax = fig.add_subplot(1, 1, 1)
plotPowerlaw(list(data_dict.values()), ax,cmap(1),
'$Tweets$')
Explanation: 安装微软雅黑字体
为了在绘图时正确显示中文，需要安装/data/文件夹中的微软雅黑字体（msyh.ttf）
详见common questions
End of explanation
tweet = '''RT @AnonKitsu: ALERT!!!!!!!!!!COPS ARE KETTLING PROTESTERS IN PARK W HELICOPTERS AND PADDYWAGONS!!!!
#OCCUPYWALLSTREET #OWS #OCCUPYNY PLEASE @chengjun @mili http://computational-communication.com
http://ccc.nju.edu.cn RT !!HELP!!!!'''
import re
import twitter_text
# https://github.com/dryan/twitter-text-py/issues/21
#Macintosh HD ▸ 用户 ▸ datalab ▸ 应用程序 ▸ anaconda ▸ lib ▸ python3.5 ▸ site-packages
Explanation: 5. 清洗tweets文本
End of explanation
import re
tweet = '''RT @AnonKitsu: @who ALERT!!!!!!!!!!COPS ARE KETTLING PROTESTERS IN PARK W HELICOPTERS AND PADDYWAGONS!!!!
#OCCUPYWALLSTREET #OWS #OCCUPYNY PLEASE @chengjun @mili http://computational-communication.com
http://ccc.nju.edu.cn RT !!HELP!!!!'''
rt_patterns = re.compile(r"(RT|via)((?:\b\W*@\w+)+)", \
re.IGNORECASE)
rt_user_name = rt_patterns.findall(tweet)[0][1].strip(' @')#.split(':')[0]
rt_user_name
import re
tweet = '''RT @AnonKitsu: @who ALERT!!!!!!!!!!COPS ARE KETTLING PROTESTERS IN PARK W HELICOPTERS AND PADDYWAGONS!!!!
#OCCUPYWALLSTREET #OWS #OCCUPYNY PLEASE @chengjun @mili http://computational-communication.com
http://ccc.nju.edu.cn RT !!HELP!!!!'''
rt_patterns = re.compile(r"(RT|via)((?:\b\W*@\w+)+)", \
re.IGNORECASE)
rt_user_name = rt_patterns.findall(tweet)[0][1].strip(' @').split(':')[0]
rt_user_name
import re
tweet = '''@chengjun:@who ALERT!!!!!!!!!!COPS ARE KETTLING PROTESTERS IN PARK W HELICOPTERS AND PADDYWAGONS!!!!
#OCCUPYWALLSTREET #OWS #OCCUPYNY PLEASE @chengjun @mili http://computational-communication.com
http://ccc.nju.edu.cn RT !!HELP!!!!'''
rt_patterns = re.compile(r"(RT|via)((?:\b\W*@\w+)+)", re.IGNORECASE)
rt_user_name = rt_patterns.findall(tweet)
print(rt_user_name)
if rt_user_name:
print('it exits.')
else:
print('None')
import re
def extract_rt_user(tweet):
rt_patterns = re.compile(r"(RT|via)((?:\b\W*@\w+)+)", re.IGNORECASE)
rt_user_name = rt_patterns.findall(tweet)
if rt_user_name:
rt_user_name = rt_user_name[0][1].strip(' @').split(':')[0]
else:
rt_user_name = None
return rt_user_name
tweet = '''RT @chengjun: ALERT!!!!!!!!!!COPS ARE KETTLING PROTESTERS IN PARK W HELICOPTERS AND PADDYWAGONS!!!!
#OCCUPYWALLSTREET #OWS #OCCUPYNY PLEASE @chengjun @mili http://computational-communication.com
http://ccc.nju.edu.cn RT !!HELP!!!!'''
extract_rt_user(tweet)
tweet = '''@chengjun: ALERT!!!!!!!!!!COPS ARE KETTLING PROTESTERS IN PARK W HELICOPTERS AND PADDYWAGONS!!!!
#OCCUPYWALLSTREET #OWS #OCCUPYNY PLEASE @chengjun @mili http://computational-communication.com
http://ccc.nju.edu.cn RT !!HELP!!!!'''
print(extract_rt_user(tweet) )
import csv
with open("../data/ows_tweets_sample.txt", 'r') as f:
chunk = f.readlines()
rt_network = []
lines = csv.reader(chunk[1:], delimiter=',', quotechar='"')
tweet_user_data = [(i[1], i[8]) for i in lines]
tweet_user_data[:3]
from collections import defaultdict
rt_network = []
rt_dict = defaultdict(int)
for k, i in enumerate(tweet_user_data):
tweet,user = i
rt_user = extract_rt_user(tweet)
if rt_user:
rt_network.append((user, rt_user)) #(rt_user,' ', user, end = '\n')
rt_dict[(user, rt_user)] += 1
#rt_network[:5]
list(rt_dict.items())[:3]
Explanation: 安装twitter_text
twitter-text-py could not be used for python 3
<del>pip install twitter-text</del>
Glyph debug the problem, and make a new repo of twitter-text-py3.
pip install twitter-text
无法正常安装的同学
可以在spyder中打开terminal安装
pip install twitter-text
End of explanation
def extract_tweet_text(tweet, at_names, urls):
for i in at_names:
tweet = tweet.replace(i, '')
for j in urls:
tweet = tweet.replace(j, '')
marks = ['RT @', '@', '"', '#', '\n', '\t', ' ']
for k in marks:
tweet = tweet.replace(k, '')
return tweet
import twitter_text
tweet = '''RT @AnonKitsu: ALERT!!!!!!!!!!COPS ARE KETTLING PROTESTERS IN PARK W HELICOPTERS AND PADDYWAGONS!!!!
#OCCUPYWALLSTREET #OWS #OCCUPYNY PLEASE @chengjun @mili http://computational-communication.com
http://ccc.nju.edu.cn RT !!HELP!!!!'''
ex = twitter_text.Extractor(tweet)
at_names = ex.extract_mentioned_screen_names()
urls = ex.extract_urls()
hashtags = ex.extract_hashtags()
rt_user = extract_rt_user(tweet)
#tweet_text = extract_tweet_text(tweet, at_names, urls)
print(at_names, urls, hashtags, rt_user,'-------->')#, tweet_text)
import csv
lines = csv.reader(chunk,delimiter=',', quotechar='"')
tweets = [i[1] for i in lines]
for tweet in tweets[:5]:
ex = twitter_text.Extractor(tweet)
at_names = ex.extract_mentioned_screen_names()
urls = ex.extract_urls()
hashtags = ex.extract_hashtags()
rt_user = extract_rt_user(tweet)
#tweet_text = extract_tweet_text(tweet, at_names, urls)
print(at_names, urls, hashtags, rt_user)
#print(tweet_text)
Explanation: 获得清洗过的推特文本
不含人名、url、各种符号（如RT @等）
End of explanation |
3,460 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
3D Fast Accurate Fourier Transform
with an extra gpu array for the 33th complex values
Step1: Loading FFT routines
Step2: Initializing Data
Gaussian
Step3: $W$ TRANSFORM FROM AXES-0
After the transfom, f_gpu[
Step4: Forward Transform
Step5: Inverse Transform
Step6: $W$ TRANSFORM FROM AXES-1
After the transfom, f_gpu[
Step7: Forward Transform
Step8: Inverse Transform
Step9: $W$ TRANSFORM FROM AXES-2
After the transfom, f_gpu[
Step10: Forward Transform
Step11: Inverse Transform | Python Code:
import numpy as np
import ctypes
from ctypes import *
import pycuda.gpuarray as gpuarray
import pycuda.driver as cuda
import pycuda.autoinit
from pycuda.compiler import SourceModule
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
import math
import time
%matplotlib inline
Explanation: 3D Fast Accurate Fourier Transform
with an extra gpu array for the 33th complex values
End of explanation
gridDIM = 64
size = gridDIM*gridDIM*gridDIM
axes0 = 0
axes1 = 1
axes2 = 2
makeC2C = 0
makeR2C = 1
makeC2R = 1
axesSplit_0 = 0
axesSplit_1 = 1
axesSplit_2 = 2
segment_axes0 = 0
segment_axes1 = 0
segment_axes2 = 0
DIR_BASE = "/home/robert/Documents/new1/FFT/code/"
# FAFT
_faft128_3D = ctypes.cdll.LoadLibrary( DIR_BASE+'FAFT128_3D_R2C.so' )
_faft128_3D.FAFT128_3D_R2C.restype = int
_faft128_3D.FAFT128_3D_R2C.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_float, ctypes.c_float, ctypes.c_int,
ctypes.c_int, ctypes.c_int, ctypes.c_int]
cuda_faft = _faft128_3D.FAFT128_3D_R2C
# Inv FAFT
_ifaft128_3D = ctypes.cdll.LoadLibrary(DIR_BASE+'IFAFT128_3D_C2R.so')
_ifaft128_3D.IFAFT128_3D_C2R.restype = int
_ifaft128_3D.IFAFT128_3D_C2R.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_float, ctypes.c_float, ctypes.c_int,
ctypes.c_int, ctypes.c_int, ctypes.c_int]
cuda_ifaft = _ifaft128_3D.IFAFT128_3D_C2R
Explanation: Loading FFT routines
End of explanation
def Gaussian(x,sigma):
return np.exp( - x**2/sigma**2/2. )/(sigma*np.sqrt( 2*np.pi ))
def fftGaussian(p,sigma):
return np.exp( - p**2*sigma**2/2. )
# Gaussian parameters
mu = 0
sigma = 1.
# Grid parameters
x_amplitude = 5.
p_amplitude = 6. # With the traditional method p amplitude is fixed to: 2 * np.pi /( 2*x_amplitude )
dx = 2*x_amplitude/float(gridDIM) # This is dx in Bailey's paper
dp = 2*p_amplitude/float(gridDIM) # This is gamma in Bailey's paper
delta = dx*dp/(2*np.pi)
x_range = np.linspace( -x_amplitude, x_amplitude-dx, gridDIM)
p = np.linspace( -p_amplitude, p_amplitude-dp, gridDIM)
x = x_range[ np.newaxis, np.newaxis, : ]
y = x_range[ np.newaxis, :, np.newaxis ]
z = x_range[ :, np.newaxis, np.newaxis ]
f = Gaussian(x,sigma)*Gaussian(y,sigma)*Gaussian(z,sigma)
plt.imshow( f[:, :, 0], extent=[-x_amplitude , x_amplitude-dx, -x_amplitude , x_amplitude-dx] )
axis_font = {'size':'24'}
plt.text( 0., 5.1, '$W$' , **axis_font)
plt.colorbar()
#plt.ylim(0,0.44)
print ' Amplitude x = ',x_amplitude
print ' Amplitude p = ',p_amplitude
print ' '
print 'sigma = ', sigma
print 'n = ', x.size
print 'dx = ', dx
print 'dp = ', dp
print ' standard fft dp = ',2 * np.pi /( 2*x_amplitude ) , ' '
print ' '
print 'delta = ', delta
print ' '
print 'The Gaussian extends to the numerical error in single precision:'
print ' min = ', np.min(f)
Explanation: Initializing Data
Gaussian
End of explanation
# Matrix for the 33th. complex values
f33 = np.zeros( [64, 1 ,64], dtype = np.complex64 )
# Copy to GPU
if 'f_gpu' in globals():
f_gpu.gpudata.free()
if 'f33_gpu' in globals():
f33_gpu.gpudata.free()
f_gpu = gpuarray.to_gpu( np.ascontiguousarray( f , dtype = np.float32 ) )
f33_gpu = gpuarray.to_gpu( np.ascontiguousarray( f33 , dtype = np.complex64 ) )
Explanation: $W$ TRANSFORM FROM AXES-0
After the transfom, f_gpu[:, :32, :] contains real values and f_gpu[:, 32:, :] contains imaginary values. f33_gpu contains the 33th. complex values
End of explanation
# Executing FFT
t_init = time.time()
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes0, axes0, makeR2C, axesSplit_0 )
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes1, axes1, makeC2C, axesSplit_0 )
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes2, axes2, makeC2C, axesSplit_0 )
t_end = time.time()
print 'computation time = ', t_end - t_init
plt.imshow( np.append( f_gpu.get()[:, :32, :], f33_gpu.get().real, axis=1 )[32,:,:]
/float(np.sqrt(size)),
extent=[-p_amplitude , p_amplitude-dp, 0, p_amplitude-dp] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( 0., 5.2, '$Re \\mathcal{F}(W)$', **axis_font )
plt.xlim(-x_amplitude , x_amplitude-dx)
plt.ylim(0 , x_amplitude)
plt.imshow( np.append( f_gpu.get()[:, 32:, :], f33_gpu.get().imag, axis=1 )[32,:,:]
/float(np.sqrt(size)),
extent=[-p_amplitude , p_amplitude-dp, 0, p_amplitude-dp] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( 0., 5.2, '$Im \\mathcal{F}(W)$', **axis_font )
plt.xlim(-x_amplitude , x_amplitude-dx)
plt.ylim(0 , x_amplitude)
Explanation: Forward Transform
End of explanation
# Executing iFFT
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes2, axes2, makeC2C, axesSplit_0 )
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes1, axes1, makeC2C, axesSplit_0 )
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes0, axes0, makeC2R, axesSplit_0 )
plt.imshow( f_gpu.get()[32,:,:]/float(size) ,
extent=[-x_amplitude , x_amplitude-dx, -x_amplitude , x_amplitude-dx] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( -1, 5.2, '$W$', **axis_font )
plt.xlim(-x_amplitude , x_amplitude-dx)
plt.ylim(-x_amplitude , x_amplitude-dx)
Explanation: Inverse Transform
End of explanation
# Matrix for the 33th. complex values
f33 = np.zeros( [64, 64, 1], dtype = np.complex64 )
# One gpu array.
if 'f_gpu' in globals():
f_gpu.gpudata.free()
if 'f33_gpu' in globals():
f33_gpu.gpudata.free()
f_gpu = gpuarray.to_gpu( np.ascontiguousarray( f , dtype = np.float32 ) )
f33_gpu = gpuarray.to_gpu( np.ascontiguousarray( f33 , dtype = np.complex64 ) )
Explanation: $W$ TRANSFORM FROM AXES-1
After the transfom, f_gpu[:, :, :64] contains real values and f_gpu[:, :, 64:] contains imaginary values. f33_gpu contains the 33th. complex values
End of explanation
# Executing FFT
t_init = time.time()
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes1, axes1, makeR2C, axesSplit_1 )
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes0, axes0, makeC2C, axesSplit_1 )
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes2, axes2, makeC2C, axesSplit_1 )
t_end = time.time()
print 'computation time = ', t_end - t_init
plt.imshow( np.append( f_gpu.get()[:, :, :32], f33_gpu.get().real, axis=2 )[32,:,:]
/float(np.sqrt(size)),
extent=[-p_amplitude , 0, -p_amplitude , p_amplitude-dp] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( 0., 5.2, '$Re \\mathcal{F}(W)$', **axis_font )
plt.xlim(-x_amplitude , 0)
plt.ylim(-x_amplitude , x_amplitude-dx)
plt.imshow( np.append( f_gpu.get()[:, :, 32:], f33_gpu.get().imag, axis=2 )[32,:,:]
/float(np.sqrt(size)),
extent=[-p_amplitude , 0, -p_amplitude , p_amplitude-dp] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( 0., 5.2, '$Im \\mathcal{F}(W)$', **axis_font )
plt.xlim(-x_amplitude , 0)
plt.ylim(-x_amplitude , x_amplitude-dx)
Explanation: Forward Transform
End of explanation
# Executing iFFT
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes2, axes2, makeC2C, axesSplit_1 )
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes0, axes0, makeC2C, axesSplit_1 )
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes1, axes1, makeC2R, axesSplit_1 )
plt.imshow( f_gpu.get()[32,:,:] /float(size) ,
extent=[-x_amplitude , x_amplitude-dx, -x_amplitude , x_amplitude-dx] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( -1, 5.2, '$W$', **axis_font )
plt.xlim(-x_amplitude , x_amplitude-dx)
plt.ylim(-x_amplitude , x_amplitude-dx)
Explanation: Inverse Transform
End of explanation
# Matrix for the 33th. complex values
f33 = np.zeros( [1, 64, 64], dtype = np.complex64 )
# One gpu array.
if 'f_gpu' in globals():
f_gpu.gpudata.free()
if 'f33_gpu' in globals():
f33_gpu.gpudata.free()
f_gpu = gpuarray.to_gpu( np.ascontiguousarray( f , dtype = np.float32 ) )
f33_gpu = gpuarray.to_gpu( np.ascontiguousarray( f33 , dtype = np.complex64 ) )
Explanation: $W$ TRANSFORM FROM AXES-2
After the transfom, f_gpu[:64, :, :] contains real values and f_gpu[64:, :, :] contains imaginary values. f33_gpu contains the 33th. complex values
End of explanation
# Executing FFT
t_init = time.time()
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes2, axes2, makeR2C, axesSplit_2 )
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes1, axes1, makeC2C, axesSplit_2 )
cuda_faft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, delta, segment_axes0, axes0, makeC2C, axesSplit_2 )
t_end = time.time()
print 'computation time = ', t_end - t_init
plt.imshow( np.append( f_gpu.get()[:32, :, :], f33_gpu.get().real, axis=0 )[:,:,32]
/float(np.sqrt(size)),
extent=[-p_amplitude , p_amplitude-dp, 0, p_amplitude-dp] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( 0., 5.2, '$Re \\mathcal{F}(W)$', **axis_font )
plt.xlim(-x_amplitude , x_amplitude-dx)
plt.ylim(0 , x_amplitude-dx)
plt.imshow( np.append( f_gpu.get()[32:, :, :], f33_gpu.get().imag, axis=0 )[:,:,32]
/float(np.sqrt(size)),
extent=[-p_amplitude , p_amplitude-dp, 0, p_amplitude-dp] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( 0., 5.2, '$Im \\mathcal{F}(W)$', **axis_font )
plt.xlim(-x_amplitude , x_amplitude-dx)
plt.ylim(0 , x_amplitude-dx)
Explanation: Forward Transform
End of explanation
# Executing iFFT
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes0, axes0, makeC2C, axesSplit_2 )
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes1, axes1, makeC2C, axesSplit_2 )
cuda_ifaft( int(f_gpu.gpudata), int(f33_gpu.gpudata), dx, -delta, segment_axes2, axes2, makeC2R, axesSplit_2 )
plt.imshow( f_gpu.get()[32,:,:]/float(size) ,
extent=[-x_amplitude , x_amplitude-dx, -x_amplitude , x_amplitude-dx] )
plt.colorbar()
axis_font = {'size':'24'}
plt.text( -1, 5.2, '$W$', **axis_font )
plt.xlim(-x_amplitude , x_amplitude-dx)
plt.ylim(-x_amplitude , x_amplitude-dx)
Explanation: Inverse Transform
End of explanation |
3,461 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
New Term Topics Methods and Document Coloring
Step1: We're setting up our corpus now. We want to show off the new get_term_topics and get_document_topics functionalities, and a good way to do so is to play around with words which might have different meanings in different context.
The word bank is a good candidate here, where it can mean either the financial institution or a river bank.
In the toy corpus presented, there are 11 documents, 5 river related and 6 finance related.
Step2: We set up the LDA model in the corpus. We set the number of topics to be 2, and expect to see one which is to do with river banks, and one to do with financial banks.
Step3: And like we expected, the LDA model has given us near perfect results. Bank is the most influential word in both the topics, as we can see. The other words help define what kind of bank we are talking about. Let's now see where our new methods fit in.
get_term_topics
The function get_term_topics returns the odds of that particular word belonging to a particular topic.
A few examples
Step4: Makes sense, the value for it belonging to topic_0 is a lot more.
Step5: This also works out well, the word finance is more likely to be in topic_1 to do with financial banks.
Step6: And this is particularly interesting. Since the word bank is likely to be in both the topics, the values returned are also very similar.
get_document_topics and Document Word-Topic Coloring
get_document_topics is an already existing gensim functionality which uses the inference function to get the sufficient statistics and figure out the topic distribution of the document.
The addition to this is the ability for us to now know the topic distribution for each word in the document.
Let us test this with two different documents which have the word bank in it, one in the finance context and one in the river context.
The get_document_topics method returns (along with the standard document topic proprtion) the word_type followed by a list sorted with the most likely topic ids, when per_word_topics is set as true.
Step7: Now what does that output mean? It means that like word_type 1, our word_type 3, which is the word bank, is more likely to be in topic_0 than topic_1.
You must have noticed that while we unpacked into doc_topics and word_topics, there is another variable - phi_values. Like the name suggests, phi_values contains the phi values for each topic for that particular word, scaled by feature length. Phi is essentially the probability of that word in that document belonging to a particular topic. The next few lines should illustrate this.
Step8: This means that word_type 0 has the following phi_values for each of the topics.
What is intresting to note is word_type 3 - because it has 2 occurences (i.e, the word bank appears twice in the bow), we can see that the scaling by feature length is very evident. The sum of the phi_values is 2, and not 1.
Now that we know exactly what get_document_topics does, let us now do the same with our second document, bow_finance.
Step9: And lo and behold, because the word bank is now used in the financial context, it immedietly swaps to being more likely associated with topic_1.
We've seen quite clearly that based on the context, the most likely topic associated with a word can change.
This differs from our previous method, get_term_topics, where it is a 'static' topic distribution.
It must also be noted that because the gensim implementation of LDA uses Variational Bayes sampling, a word_type in a document is only given one topic distribution. For example, the sentence 'the bank by the river bank' is likely to be assigned to topic_0, and each of the bank word instances have the same distribution.
get_document_topics for entire corpus
You can get doc_topics, word_topics and phi_values for all the documents in the corpus in the following manner
Step10: In case you want to store doc_topics, word_topics and phi_values for all the documents in the corpus in a variable and later access details of a particular document using its index, it can be done in the following manner
Step11: Now, I can access details of a particular document, say Document #3, as follows
Step12: We can print details for all the documents (as shown above), in the following manner
Step13: Coloring topic-terms
These methods can come in handy when we want to color the words in a corpus or a document. If we wish to color the words in a corpus (i.e, color all the words in the dictionary of the corpus), then get_term_topics would be a better choice. If not, get_document_topics would do the trick.
We'll now attempt to color these words and plot it using matplotlib.
This is just one way to go about plotting words - there are more and better ways.
WordCloud is such a python package which also does this.
For our simple illustration, let's keep topic_0 as red, and topic_1 as blue.
Step14: Let us revisit our old examples to show some examples of document coloring
Step15: What is fun to note here is that while bank was colored red in our first example, it is now blue because of the financial context - something which the numbers proved to us before. | Python Code:
from gensim.corpora import Dictionary
from gensim.models import ldamodel
import numpy
%matplotlib inline
Explanation: New Term Topics Methods and Document Coloring
End of explanation
texts = [['bank','river','shore','water'],
['river','water','flow','fast','tree'],
['bank','water','fall','flow'],
['bank','bank','water','rain','river'],
['river','water','mud','tree'],
['money','transaction','bank','finance'],
['bank','borrow','money'],
['bank','finance'],
['finance','money','sell','bank'],
['borrow','sell'],
['bank','loan','sell']]
dictionary = Dictionary(texts)
corpus = [dictionary.doc2bow(text) for text in texts]
Explanation: We're setting up our corpus now. We want to show off the new get_term_topics and get_document_topics functionalities, and a good way to do so is to play around with words which might have different meanings in different context.
The word bank is a good candidate here, where it can mean either the financial institution or a river bank.
In the toy corpus presented, there are 11 documents, 5 river related and 6 finance related.
End of explanation
numpy.random.seed(1) # setting random seed to get the same results each time.
model = ldamodel.LdaModel(corpus, id2word=dictionary, num_topics=2)
model.show_topics()
Explanation: We set up the LDA model in the corpus. We set the number of topics to be 2, and expect to see one which is to do with river banks, and one to do with financial banks.
End of explanation
model.get_term_topics('water')
Explanation: And like we expected, the LDA model has given us near perfect results. Bank is the most influential word in both the topics, as we can see. The other words help define what kind of bank we are talking about. Let's now see where our new methods fit in.
get_term_topics
The function get_term_topics returns the odds of that particular word belonging to a particular topic.
A few examples:
End of explanation
model.get_term_topics('finance')
Explanation: Makes sense, the value for it belonging to topic_0 is a lot more.
End of explanation
model.get_term_topics('bank')
Explanation: This also works out well, the word finance is more likely to be in topic_1 to do with financial banks.
End of explanation
bow_water = ['bank','water','bank']
bow_finance = ['bank','finance','bank']
bow = model.id2word.doc2bow(bow_water) # convert to bag of words format first
doc_topics, word_topics, phi_values = model.get_document_topics(bow, per_word_topics=True)
word_topics
Explanation: And this is particularly interesting. Since the word bank is likely to be in both the topics, the values returned are also very similar.
get_document_topics and Document Word-Topic Coloring
get_document_topics is an already existing gensim functionality which uses the inference function to get the sufficient statistics and figure out the topic distribution of the document.
The addition to this is the ability for us to now know the topic distribution for each word in the document.
Let us test this with two different documents which have the word bank in it, one in the finance context and one in the river context.
The get_document_topics method returns (along with the standard document topic proprtion) the word_type followed by a list sorted with the most likely topic ids, when per_word_topics is set as true.
End of explanation
phi_values
Explanation: Now what does that output mean? It means that like word_type 1, our word_type 3, which is the word bank, is more likely to be in topic_0 than topic_1.
You must have noticed that while we unpacked into doc_topics and word_topics, there is another variable - phi_values. Like the name suggests, phi_values contains the phi values for each topic for that particular word, scaled by feature length. Phi is essentially the probability of that word in that document belonging to a particular topic. The next few lines should illustrate this.
End of explanation
bow = model.id2word.doc2bow(bow_finance) # convert to bag of words format first
doc_topics, word_topics, phi_values = model.get_document_topics(bow, per_word_topics=True)
word_topics
Explanation: This means that word_type 0 has the following phi_values for each of the topics.
What is intresting to note is word_type 3 - because it has 2 occurences (i.e, the word bank appears twice in the bow), we can see that the scaling by feature length is very evident. The sum of the phi_values is 2, and not 1.
Now that we know exactly what get_document_topics does, let us now do the same with our second document, bow_finance.
End of explanation
all_topics = model.get_document_topics(corpus, per_word_topics=True)
for doc_topics, word_topics, phi_values in all_topics:
print('New Document \n')
print 'Document topics:', doc_topics
print 'Word topics:', word_topics
print 'Phi values:', phi_values
print(" ")
print('-------------- \n')
Explanation: And lo and behold, because the word bank is now used in the financial context, it immedietly swaps to being more likely associated with topic_1.
We've seen quite clearly that based on the context, the most likely topic associated with a word can change.
This differs from our previous method, get_term_topics, where it is a 'static' topic distribution.
It must also be noted that because the gensim implementation of LDA uses Variational Bayes sampling, a word_type in a document is only given one topic distribution. For example, the sentence 'the bank by the river bank' is likely to be assigned to topic_0, and each of the bank word instances have the same distribution.
get_document_topics for entire corpus
You can get doc_topics, word_topics and phi_values for all the documents in the corpus in the following manner :
End of explanation
topics = model.get_document_topics(corpus, per_word_topics=True)
all_topics = [(doc_topics, word_topics, word_phis) for doc_topics, word_topics, word_phis in topics]
Explanation: In case you want to store doc_topics, word_topics and phi_values for all the documents in the corpus in a variable and later access details of a particular document using its index, it can be done in the following manner:
End of explanation
doc_topic, word_topics, phi_values = all_topics[2]
print 'Document topic:', doc_topics, "\n"
print 'Word topic:', word_topics, "\n"
print 'Phi value:', phi_values
Explanation: Now, I can access details of a particular document, say Document #3, as follows:
End of explanation
for doc in all_topics:
print('New Document \n')
print 'Document topic:', doc[0]
print 'Word topic:', doc[1]
print 'Phi value:', doc[2]
print(" ")
print('-------------- \n')
Explanation: We can print details for all the documents (as shown above), in the following manner:
End of explanation
# this is a sample method to color words. Like mentioned before, there are many ways to do this.
def color_words(model, doc):
import matplotlib.pyplot as plt
import matplotlib.patches as patches
# make into bag of words
doc = model.id2word.doc2bow(doc)
# get word_topics
doc_topics, word_topics, phi_values = model.get_document_topics(doc, per_word_topics=True)
# color-topic matching
topic_colors = { 0:'red', 1:'blue'}
# set up fig to plot
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
# a sort of hack to make sure the words are well spaced out.
word_pos = 1/len(doc)
# use matplotlib to plot words
for word, topics in word_topics:
ax.text(word_pos, 0.8, model.id2word[word],
horizontalalignment='center',
verticalalignment='center',
fontsize=20, color=topic_colors[topics[0]], # choose just the most likely topic
transform=ax.transAxes)
word_pos += 0.2 # to move the word for the next iter
ax.set_axis_off()
plt.show()
Explanation: Coloring topic-terms
These methods can come in handy when we want to color the words in a corpus or a document. If we wish to color the words in a corpus (i.e, color all the words in the dictionary of the corpus), then get_term_topics would be a better choice. If not, get_document_topics would do the trick.
We'll now attempt to color these words and plot it using matplotlib.
This is just one way to go about plotting words - there are more and better ways.
WordCloud is such a python package which also does this.
For our simple illustration, let's keep topic_0 as red, and topic_1 as blue.
End of explanation
# our river bank document
bow_water = ['bank','water','bank']
color_words(model, bow_water)
bow_finance = ['bank','finance','bank']
color_words(model, bow_finance)
Explanation: Let us revisit our old examples to show some examples of document coloring
End of explanation
# sample doc with a somewhat even distribution of words among the likely topics
doc = ['bank', 'water', 'bank', 'finance', 'money','sell','river','fast','tree']
color_words(model, doc)
Explanation: What is fun to note here is that while bank was colored red in our first example, it is now blue because of the financial context - something which the numbers proved to us before.
End of explanation |
3,462 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<img src='static/uff-bw.svg' width='20%' align='left'/>
Multi-Objective Optimization with Estimation of Distribution Algorithms
Luis Martí/IC/UFF
http
Step1: How we handle multiple -and conflictive- objectives?
It's "easy"
Step2: Planting a constant seed to always have the same results (and avoid surprises in class). -you should not do this in a real-world case!
Step3: To start, lets have a visual example of the Pareto dominance relationship in action.
In this notebook we will deal with two-objective problems in order to simplify visualization.
Therefore, we can create
Step5: An illustrative MOP
Step6: Preparing a DEAP toolbox with Dent.
Step7: Defining attributes, individuals and population.
Step8: Creating an example population distributed as a mesh.
Step9: Visualizing Dent
Step10: We also need a_given_individual.
Step11: Implementing the Pareto dominance relation between two individuals.
Step12: Note
Step13: Lets compute the set of individuals that are dominated by a_given_individual, the ones that dominate it (its dominators) and the remaining ones.
Step14: Having a_given_individual (blue dot) we can now plot those that are dominated by it (in green), those that dominate it (in red) and those that are uncomparable.
Step15: Obtaining the nondominated front.
Step16: So, is this the end?
Ok, now we know how to solve MOPs by sampling the search space.
MOPs, in the general case are NP-hard problems.
Brute force is never the solution in just a-little-more-complex cases.
An example, solving the TSP problem using brute force
Step17: Describing attributes, individuals and population and defining the selection, mating and mutation operators.
Step18: Let's also use the toolbox to store other configuration parameters of the algorithm. This will show itself usefull when performing massive experiments.
Step19: A compact NSGA-II implementation
Storing all the required information in the toolbox and using DEAP's algorithms.eaMuPlusLambda function allows us to create a very compact -albeit not a 100% exact copy of the original- implementation of NSGA-II.
Step20: Running the algorithm
We are now ready to run our NSGA-II.
Step21: We can now get the Pareto fronts in the results (res).
Step22: Resulting Pareto fronts
Step23: It is better to make an animated plot of the evolution as it takes place.
Animating the evolutionary process
We create a stats to store the individuals not only their objective function values.
Step24: Re-run the algorithm to get the data necessary for plotting.
Step25: The previous animation makes the notebook too big for online viewing. To circumvent this, it is better to save the animation as video and (manually) upload it to YouTube.
Step26: Here it is clearly visible how the algorithm "jumps" from one local-optimum to a better one as evolution takes place.
MOP benchmark problem toolkits
Each problem instance is meant to test the algorithms with regard with a given feature
Step27: DTLZ7 has many disconnected Pareto-optimal fronts.
<div align='center'><img src='http
Step28: How does our NSGA-II behaves when faced with different benchmark problems?
Step29: Running NSGA-II solving all problems. Now it takes longer.
Step30: Creating this animation takes more programming effort.
Step31: Saving the animation as video and uploading it to YouTube.
Step32: It is interesting how the algorithm deals with each problem
Step33: We add a experiment_name to toolbox that we will fill up later on.
Step34: We can now replicate this toolbox instance and then modify the mutation probabilities.
Step35: Now toolboxes is a list of copies of the same toolbox. One for each experiment configuration (population size).
...but we still have to set the population sizes in the elements of toolboxes.
Step36: Experiment design
As we are dealing with stochastic methods their results should be reported relying on an statistical analysis.
A given experiment (a toolbox instance in our case) should be repeated a sufficient amount of times.
In theory, the more runs the better, but how much in enough? In practice, we could say that about 30 runs is enough.
The non-dominated fronts produced by each experiment run should be compared to each other.
We have seen in class that a number of performance indicators, like the hypervolume, additive and multiplicative epsilon indicators, among others, have been proposed for that task.
We can use statistical visualizations like box plots or violin plots to make a visual assessment of the indicator values produced in each run.
We must apply a set of statistical hypothesis tests in order to reach an statistically valid judgment of the results of an algorithms.
Note
Step37: Running experiments in parallel
As we are now solving more demanding problems it would be nice to make our algorithms to run in parallel and profit from modern multi-core CPUs.
In DEAP it is very simple to parallelize an algorithm (if it has been properly programmed) by providing a parallel map() function throu the toolbox.
Local parallelization can be achieved using Python's multiprocessing or concurrent.futures modules.
Cluster parallelization can be achived using IPython Parallel or SCOOP, that seems to be recommended by the DEAP guys as it was part of it.
Note
Step38: A side-effect of using process-based parallelization
Process-based parallelization based on multiprocessing requires that the parameters passed to map() be pickleable.
The direct consequence is that lambda functions can not be directly used.
This is will certainly ruin the party to all lambda fans out there! -me included.
Hence we need to write some wrapper functions instead.
But, that wrapper function can take care of filtering out dominated individuals in the results.
Step39: All set! Run the experiments...
Step40: As you can see, even this relatively small experiment took lots of time!
As running the experiments takes so long, lets save the results so we can use them whenever we want.
Step41: In case you need it, this file is included in the github repository.
To load the results we would just have to
Step42: results is a dictionary, but a pandas DataFrame is a more handy container for the results.
Step43: A first glace at the results
Step44: The local Pareto-optimal fronts are clearly visible!
Calculating performance indicators
As already mentioned, we need to evaluate the quality of the solutions produced in every execution of the algorithm.
We will use the hypervolumne indicator for that.
We already filtered each population a leave only the non-dominated individuals.
Calculating the reference point
Step45: We can now compute the hypervolume of the Pareto-optimal fronts yielded by each algorithm run.
Step46: How can we interpret the indicators?
Option A
Step47: Option B
Step48: Option C
Step49: The Kruskal-Wallis H-test tests the null hypothesis that the population median of all of the groups are equal.
It is a non-parametric version of ANOVA.
The test works on 2 or more independent samples, which may have different sizes.
Note that rejecting the null hypothesis does not indicate which of the groups differs.
Post-hoc comparisons between groups are required to determine which groups are different.
Step50: We now can assert that the results are not the same but which ones are different or similar to the others the others?
In case that the null hypothesis of the Kruskal-Wallis is rejected the Conover–Inman procedure (Conover, 1999, pp. 288-290) can be applied in a pairwise manner in order to determine if the results of one algorithm were significantly better than those of the other.
Conover, W. J. (1999). Practical Nonparametric Statistics. John Wiley & Sons, New York, 3rd edition.
Note
Step51: We now know in what cases the difference is sufficient as to say that one result is better than the other.
Another alternative is the Friedman test.
Its null hypothesis that repeated measurements of the same individuals have the same distribution.
It is often used to test for consistency among measurements obtained in different ways.
For example, if two measurement techniques are used on the same set of individuals, the Friedman test can be used to determine if the two measurement techniques are consistent.
Step52: Mann–Whitney U test (also called the Mann–Whitney–Wilcoxon (MWW), Wilcoxon rank-sum test (WRS), or Wilcoxon–Mann–Whitney test) is a nonparametric test of the null hypothesis that two populations are the same against an alternative hypothesis, especially that a particular population tends to have larger values than the other.
It has greater efficiency than the $t$-test on non-normal distributions, such as a mixture of normal distributions, and it is nearly as efficient as the $t$-test on normal distributions.
Step53: The familywise error rate (FWER) is the probability of making one or more false discoveries, or type I errors, among all the hypotheses when performing multiple hypotheses tests.
Example
Step54: Let's apply the corrected alpha to raw_p_values. If we have a cell with a True value that means that those two results are the same. | Python Code:
import time, array, random, copy, math
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
%config InlineBackend.figure_format = 'retina'
Explanation: <img src='static/uff-bw.svg' width='20%' align='left'/>
Multi-Objective Optimization with Estimation of Distribution Algorithms
Luis Martí/IC/UFF
http://lmarti.com; [email protected]
Why we need artificial intelligence?
What does intelligence implies:
* infer, deduct, learn, create and adapt;
* to be able to deal with NP-hard problems $\rightarrow$ search and optimization problems;
* handle uncertainly, contradiction and noise.
<br/><p/><br/>
<div align='center'>
AI is the how computer science attempts to answer the question 'What are we?'
</div>
In this talk
Multi-objective optimization problems (MOPs).
Multi-objective evolutionary algorithms (MOEAs/EMOAs).
Many-objective problems and the need for better MOEAs.
Multi-objective estimation of distribution algorithms.
Experiment design and comparing results.
Salient issues and research directions.
About the slides
<img src='http://jupyter.org/assets/nav_logo.svg' width='38%'>
You may notice that I will be running some code inside the slides.
That is because the slides are programmed as a Jupyter (IPython) notebook.
If you are viewing this as a "plain" notebook, be warned that the slide version is the best way of viewing it.
You can get them from https://github.com/lmarti/scalable-moedas-talk.
You are free to try them and experiment on your own.
End of explanation
from deap import algorithms, base, benchmarks, tools, creator
Explanation: How we handle multiple -and conflictive- objectives?
It's "easy": we do it all the time.
<br/>
<div align='center'><img src='http://imgs.xkcd.com/comics/fuck_grapefruit.png' width='65%' align='center'/>
taken from http://xkcd.com/388/</div>
Multi-objective optimization
Most -if not all- optimization problems involve more than one objective function to be optimized simultaneously.
Sometimes those other objectives are converted to constraints or fixed to default values, but they are still there.
Multi-objective optimization has been applied in many fields of science where optimal decisions need to be taken in the presence of trade-offs between two or more conflicting objectives.
A Multi-objective Optimization Problem (MOP)
$$
\begin{array}{rl}
\mathrm{minimize} & \mathbf{F}(\mathbf{x})=\langle f_1(\mathbf{x}),\ldots,f_M(\mathbf{x})\rangle\,,\
\mathrm{subject}\ \mathrm{to} & c_1(\mathbf{x}),\ldots,c_C(\mathbf{x})\le 0\,,\
& d_1(\mathbf{x}),\ldots,d_D(\mathbf{x})= 0\,,\
& \text{with}\ \mathbf{x}\in\mathcal{D}\,,
\end{array}
$$
$\mathcal{D}$ is known as the decision set or search set.
functions $f_1(\mathbf{x}),\ldots,f_M(\mathbf{x})$ are the objective functions.
Image set, $\mathcal{O}$, result of the projection of $\mathcal{D}$ via $f_1(\mathbf{x}),\ldots,f_M(\mathbf{x})$ is called objective set ($\mathbf{F}:\mathcal{D}\rightarrow\mathcal{O}$).
$c_1(\mathbf{x}),\ldots,c_C(\mathbf{x})\le 0$ and $d_1(\mathbf{x}),\ldots,d_D(\mathbf{x})= 0$ express the constraints imposed on the values of $\mathbf{x}$.
Note 1: In case you are -still- wondering, a maximization problem can be posed as the minimization one: $\min\ -\mathbf{F}(\mathbf{x})$.
Note 2: If $M=1$ the problem reduces to a single-objective optimization problem.
Example: A two variables and two objectives MOP
<div align='center'><img src='static/mop-2d.jpg' height='56%' align='center'/></div>
MOP (optimal) solutions
Usually, there is not a unique solution that minimizes all objective functions simultaneously, but, instead, a set of equally good trade-off solutions.
Optimality can be defined in terms of the Pareto dominance relation:
* having $\mathbf{x},\mathbf{y}\in\mathcal{D}$, $\mathbf{x}$ is said to dominate $\mathbf{y}$ (expressed as $\mathbf{x}\preccurlyeq\mathbf{y}$) iff $\forall f_j$, $f_j(\mathbf{x})\leq f_j(\mathbf{y})$ and $\exists f_i$ such that $f_i(\mathbf{x})< f_i(\mathbf{y})$.
* Having the set $\mathcal{A}$. $\mathcal{A}^\ast$, the non-dominated subset of $\mathcal{A}$, is defined as
$$
\mathcal{A}^\ast=\left{ \mathbf{x}\in\mathcal{A} \left|\not\exists\mathbf{y}\in\mathcal{A}:\mathbf{y}\preccurlyeq\mathbf{x}\right.\right}.
$$
The Pareto-optimal set, $\mathcal{D}^{\ast}$, is the solution of the problem. It is the subset of non-dominated elements of $\mathcal{D}$. It is also known as the efficient set.
It consists of solutions that cannot be improved in any of the objectives without degrading at least one of the other objectives.
Its image in objective set is called the Pareto-optimal front, $\mathcal{O}^\ast$.
Evolutionary algorithms generally yield a set of non-dominated solutions, $\mathcal{P}^\ast$, that approximates $\mathcal{D}^{\ast}$.
Visualizing the Pareto dominance relation
We will be using DEAP, a python module for evolutionary computing.
End of explanation
random.seed(a=42)
Explanation: Planting a constant seed to always have the same results (and avoid surprises in class). -you should not do this in a real-world case!
End of explanation
creator.create("FitnessMin", base.Fitness, weights=(-1.0,-1.0))
creator.create("Individual", array.array, typecode='d',
fitness=creator.FitnessMin)
Explanation: To start, lets have a visual example of the Pareto dominance relationship in action.
In this notebook we will deal with two-objective problems in order to simplify visualization.
Therefore, we can create:
End of explanation
def dent(individual, lbda = 0.85):
Implements the test problem Dent
Num. variables = 2; bounds in [-1.5, 1.5]; num. objetives = 2.
@author Cesar Revelo
d = lbda * math.exp(-(individual[0] - individual[1]) ** 2)
f1 = 0.5 * (math.sqrt(1 + (individual[0] + individual[1]) ** 2) + \
math.sqrt(1 + (individual[0] - individual[1]) ** 2) + \
individual[0] - individual[1]) + d
f2 = 0.5 * (math.sqrt(1 + (individual[0] + individual[1]) ** 2) + \
math.sqrt(1 + (individual[0] - individual[1]) ** 2) - \
individual[0] + individual[1]) + d
return f1, f2
Explanation: An illustrative MOP: Dent
$$
\begin{array}{rl}
\text{minimize} & f_1(\mathbf{x}),f_2(\mathbf{x}) \
\text{such that} & f_1(\mathbf{x}) = \frac{1}{2}\left( \sqrt{1 + (x_1 + x_2)^2} \sqrt{1 + (x_1 - x_2)^2} + x_1 -x_2\right) + d,\
& f_2(\mathbf{x}) = \frac{1}{2}\left( \sqrt{1 + (x_1 + x_2)^2} \sqrt{1 + (x_1 - x_2)^2} - x_1 -x_2\right) + d,\
\text{with}& d = \lambda e^{-\left(x_1-x_2\right)^2}\ (\text{generally }\lambda=0.85) \text{ and }\
& \mathbf{x}\in \left[-1.5,1.5\right]^2.
\end{array}
$$
Implementing the Dent problem
End of explanation
toolbox = base.Toolbox()
BOUND_LOW, BOUND_UP = -1.5, 1.5
NDIM = 2
toolbox.register("evaluate", dent)
Explanation: Preparing a DEAP toolbox with Dent.
End of explanation
def uniform(low, up, size=None):
try:
return [random.uniform(a, b) for a, b in zip(low, up)]
except TypeError:
return [random.uniform(a, b) for a, b in zip([low] * size, [up] * size)]
toolbox.register("attr_float", uniform, BOUND_LOW, BOUND_UP, NDIM)
toolbox.register("individual", tools.initIterate,
creator.Individual, toolbox.attr_float)
toolbox.register("population", tools.initRepeat, list,
toolbox.individual)
Explanation: Defining attributes, individuals and population.
End of explanation
num_samples = 50
limits = [np.arange(BOUND_LOW, BOUND_UP, (BOUND_UP - BOUND_LOW)/num_samples)] * NDIM
sample_x = np.meshgrid(*limits)
flat = []
for i in range(len(sample_x)):
x_i = sample_x[i]
flat.append(x_i.reshape(num_samples**NDIM))
example_pop = toolbox.population(n=num_samples**NDIM)
for i, ind in enumerate(example_pop):
for j in range(len(flat)):
ind[j] = flat[j][i]
fitnesses = toolbox.map(toolbox.evaluate, example_pop)
for ind, fit in zip(example_pop, fitnesses):
ind.fitness.values = fit
Explanation: Creating an example population distributed as a mesh.
End of explanation
plt.figure(figsize=(11,5))
plt.subplot(1,2,1)
for ind in example_pop: plt.plot(ind[0], ind[1], 'k.', ms=3)
plt.xlabel('$x_1$');plt.ylabel('$x_2$');plt.title('Decision space');
plt.subplot(1,2,2)
for ind in example_pop: plt.plot(ind.fitness.values[0], ind.fitness.values[1], 'k.', ms=3)
plt.xlabel('$f_1(\mathbf{x})$');plt.ylabel('$f_2(\mathbf{x})$');
plt.xlim((0.5,3.6));plt.ylim((0.5,3.6)); plt.title('Objective space');
Explanation: Visualizing Dent
End of explanation
a_given_individual = toolbox.population(n=1)[0]
a_given_individual[0] = 0.5
a_given_individual[1] = 0.5
a_given_individual.fitness.values = toolbox.evaluate(a_given_individual)
Explanation: We also need a_given_individual.
End of explanation
def pareto_dominance(ind1, ind2):
'Returns `True` if `ind1` dominates `ind2`.'
extrictly_better = False
for item1 in ind1.fitness.values:
for item2 in ind2.fitness.values:
if item1 > item2:
return False
if not extrictly_better and item1 < item2:
extrictly_better = True
return extrictly_better
Explanation: Implementing the Pareto dominance relation between two individuals.
End of explanation
def efficient_pareto_dominance(ind1, ind2):
return tools.emo.isDominated(ind1.fitness.values, ind2.fitness.values)
Explanation: Note: Bear in mind that DEAP implements a Pareto dominance relation that probably is more efficient than this implementation. The previous function would be something like:
End of explanation
dominated = [ind for ind in example_pop
if pareto_dominance(a_given_individual, ind)]
dominators = [ind for ind in example_pop
if pareto_dominance(ind, a_given_individual)]
others = [ind for ind in example_pop
if not ind in dominated and not ind in dominators]
def plot_dent():
'Plots the points in decision and objective spaces.'
plt.figure(figsize=(10,5))
plt.subplot(1,2,1)
for ind in dominators: plt.plot(ind[0], ind[1], 'r.')
for ind in dominated: plt.plot(ind[0], ind[1], 'g.')
for ind in others: plt.plot(ind[0], ind[1], 'k.', ms=3)
plt.plot(a_given_individual[0], a_given_individual[1], 'bo', ms=6);
plt.xlabel('$x_1$');plt.ylabel('$x_2$');
plt.title('Decision space');
plt.subplot(1,2,2)
for ind in dominators: plt.plot(ind.fitness.values[0], ind.fitness.values[1], 'r.', alpha=0.7)
for ind in dominated: plt.plot(ind.fitness.values[0], ind.fitness.values[1], 'g.', alpha=0.7)
for ind in others: plt.plot(ind.fitness.values[0], ind.fitness.values[1], 'k.', alpha=0.7, ms=3)
plt.plot(a_given_individual.fitness.values[0], a_given_individual.fitness.values[1], 'bo', ms=6);
plt.xlabel('$f_1(\mathbf{x})$');plt.ylabel('$f_2(\mathbf{x})$');
plt.xlim((0.5,3.6));plt.ylim((0.5,3.6));
plt.title('Objective space');
plt.tight_layout()
Explanation: Lets compute the set of individuals that are dominated by a_given_individual, the ones that dominate it (its dominators) and the remaining ones.
End of explanation
plot_dent()
Explanation: Having a_given_individual (blue dot) we can now plot those that are dominated by it (in green), those that dominate it (in red) and those that are uncomparable.
End of explanation
non_dom = tools.sortNondominated(example_pop, k=len(example_pop),
first_front_only=True)[0]
plt.figure(figsize=(5,5))
for ind in example_pop:
plt.plot(ind.fitness.values[0], ind.fitness.values[1], 'k.', ms=3, alpha=0.5)
for ind in non_dom:
plt.plot(ind.fitness.values[0], ind.fitness.values[1], 'bo', alpha=0.74, ms=5)
Explanation: Obtaining the nondominated front.
End of explanation
toolbox = base.Toolbox()
BOUND_LOW, BOUND_UP = 0.0, 1.0
toolbox.register("evaluate", lambda ind: benchmarks.dtlz3(ind, 2))
Explanation: So, is this the end?
Ok, now we know how to solve MOPs by sampling the search space.
MOPs, in the general case are NP-hard problems.
Brute force is never the solution in just a-little-more-complex cases.
An example, solving the TSP problem using brute force:
<table>
<tr><th>$n$ cities</th><th>time</th>
<tr><td>10</td><td>3 secs</td></tr>
<tr><td>12</td><td>3 secs × 11 × 12 = 6.6 mins</td></tr>
<tr><td>14</td><td>6.6 mins × 13 × 14 = 20 hours</td></tr>
<tr><td>24</td><td>3 secs × 24! / 10! = <a href="https://www.google.com/search?q=3+seconds+*+24!+%2F+10!+in+years">16 billion years</a></td></tr></table>
Note: See my PhD EC course notebooks https://github.com/lmarti/evolutionary-computation-course on solving the TSP problem using EAs.
Preference-based alternatives
A Decision Maker can define a set of weights $w_1,\ldots,w_M$ for each function $f_1(),\ldots,f_M()$.
We can convert a MOP into a SOP:
$$
\begin{array}{rl}
\mathrm{minimize} & F(\mathbf{x})= w_1f_1(\mathbf{x})+\cdots + w_if_i(\mathbf{x}) +\cdots +w_Mf_M(\mathbf{x})\,,\
\mathrm{subject}\ \mathrm{to} & c_1(\mathbf{x}),\ldots,c_C(\mathbf{x})\le 0\,,\
& d_1(\mathbf{x}),\ldots,d_D(\mathbf{x})= 0\,,\
& \text{with}\ \mathbf{x}\in\mathcal{D}\,,
\end{array}
$$
A single-objective optimizer $\implies$ only one solution not the complete PF.
Mathematical programming.
Requires (a lot) of a priori knowledge but is relatively simple.
The Decision Maker
<div align='center'><img src='static/920267262856611.jpeg' width='56%'></div>
Lexicographical ordering of the objectives
<table><tr><td width='25%'>
<div align='center'><img align='center'src="http://upload.wikimedia.org/wikipedia/commons/f/fb/Animal_Farm_-_1st_edition.jpg" width="100%"></div>
</td><td width='75%'>
<h3> All objectives are important...</h3>
<h2>...but some objectives are more important than others.</h2>
</td></tr></table>
Better idea: Use the Pareto dominance relation to guide the search
We can use the Pareto dominance relation to determine how good an individual is.
Ideas:
For a solution $\mathbf{x}$, how many individuals dominate $\mathbf{x}$?
... and how many $\mathbf{x}$ dominates?
This looks like the perfect task for an evolutionary algorithm.
Evolutionary Algorithms
<div align='center'><img src='static/moea.png' width='65%'></div>
Mating selection + Variation (Offsping generation) + Enviromental selection $\implies$ global + local parallel search features.
Elements to take into account using evolutionary algorithms
Individual representation (binary, Gray, floating-point, etc.);
evaluation and fitness assignment;
mating selection, that establishes a partial order of individuals in the population using their fitness function value as reference and determines the degree at which individuals in the population will take part in the generation of new (offspring) individuals.
variation, that applies a range of evolution-inspired operators, like crossover, mutation, etc., to synthesize offspring individuals from the current (parent) population.
This process is supposed to prime the fittest individuals so they play a bigger role in the generation of the offspring.
environmental selection, that merges the parent and offspring individuals to produce the population that will be used in the next iteration. This process often involves the deletion of some individuals using a given criterion in order to keep the amount of individuals bellow a certain threshold.
stopping criterion, that determines when the algorithm should be stopped, either because the optimum was reach or because the optimization process is not progressing.
Pseudocode of an evolutionary algorithm
```
def evolutionary_algorithm():
populations = [] # a list with all the populations
populations[0] = initialize_population(pop_size)
t = 0
while not stop_criterion(populations[t]):
fitnesses = evaluate(populations[t])
offspring = matting_and_variation(populations[t],
fitnesses)
populations[t+1] = environmental_selection(
populations[t],
offspring)
t = t+1
```
The crossover operator
One point crossover
<img src='https://upload.wikimedia.org/wikipedia/commons/5/56/OnePointCrossover.svg' width='47%'>
Two-point crossover
<img src='https://upload.wikimedia.org/wikipedia/commons/c/cd/TwoPointCrossover.svg' width='47%'>
The Non-dominated Sorting Genetic Algorithm (NSGA-II)
NSGA-II algorithm is one of the pillars of the EMO field.
Deb, K., Pratap, A., Agarwal, S., Meyarivan, T., A fast and elitist multiobjective genetic algorithm: NSGA-II, IEEE Transactions on Evolutionary Computation, vol.6, no.2, pp.182,197, Apr 2002 doi: 10.1109/4235.996017.
Key element of NSGA-II
Fitness assignment relies on the Pareto dominance relation:
Rank individuals according the dominance relations established between them.
Individuals with the same domination rank are then compared using a local crowding distance.
NSGA-II fitness assigment in detail
The first step consists in classifying the individuals in a series of categories $\mathcal{F}_1,\ldots,\mathcal{F}_L$.
Each of these categories store individuals that are only dominated by the elements of the previous categories,
$$
\begin{array}{rl}
\forall \mathbf{x}\in\mathcal{F}i: &\exists \mathbf{y}\in\mathcal{F}{i-1} \text{ such that } \mathbf{y}\preccurlyeq\mathbf{x},\text{ and }\
&\not\exists\mathbf{z}\in \mathcal{P}t\setminus\left( \mathcal{F}_1\cup\ldots\cup\mathcal{F}{i-1}
\right)\text{ that }\mathrm{z}\preccurlyeq\mathrm{x}\,;
\end{array}
$$
with $\mathcal{F}_1$ equal to $\mathcal{P}_t^\ast$, the set of non-dominated individuals of $\mathcal{P}_t$.
After all individuals are ranked a local crowding distance is assigned to them.
The use of this distance primes individuals more isolated with respect to others.
Crowding distance
For each category set $\mathcal{F}_l$, having $f_l=|\mathcal{F}_l|$,
for each individual $\mathrm{x}i\in\mathcal{F}_l$, set $d{i}=0$.
for each objective function $m=1,\ldots,M$,
$\mathbf{I}=\mathrm{sort}\left(\mathcal{F}_l,m\right)$ (generate index vector).
$d_{I_1}^{(l)}=d_{I_{f_l}}^{(l)}=\infty$. (key)
for $i=2,\ldots,f_l-1$,
Update distances as,
$$
d_i = d_i + \frac{f_m\left(\mathrm{x}{I{i+1}}\right)-f_m\left(\mathrm{x}{I{i+1}}\right)} {f_m\left(\mathrm{x}{I{1}}\right)-f_m\left(\mathrm{x}{I{f_l}}\right)}$$
Here the $\mathrm{sort}\left(\mathcal{F},m\right)$ function produces an ordered index vector $\mathbf{I}$ with respect to objective function $m$.
<div align='center'><img src='static/population.png' width='74%'/></div>
Sorting the population by rank and distance.
Having the individual ranks and their local distances they are sorted using the crowded comparison operator, stated as:
An individual $\mathrm{x}i$ _is better than $\mathrm{x}_j$ if:
$\mathrm{x}_i$ has a better rank: $\mathrm{x}_i\in\mathcal{F}_k$, $\mathrm{x}_j\in\mathcal{F}_l$ and $k<l$, or;
if $k=l$ and $d_i>d_j$.
Now we have key element of the the non-dominated sorting GA.
Implementing NSGA-II
We will deal with DTLZ3, which is a more difficult test problem.
DTLZ problems can be configured to have as many objectives as desired, but as we want to visualize results we will stick to two objectives.
The Pareto-optimal front of DTLZ3 lies in the first orthant of a unit (radius 1) hypersphere located at the coordinate origin ($\mathbf{0}$).
It has many local optima that run parallel to the global optima and render the optimization process more complicated.
<div align='center'><img src='http://www.cs.cinvestav.mx/~emoobook/apendix-e/galeria4/dtlz3a.jpg' width="65%" align='center'/></div>
from Coello Coello, Lamont and Van Veldhuizen (2007) Evolutionary Algorithms for Solving Multi-Objective Problems, Second Edition. Springer Appendix E.
New toolbox instance with the necessary components.
End of explanation
toolbox.register("attr_float", uniform, BOUND_LOW, BOUND_UP, NDIM)
toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.attr_float)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxSimulatedBinaryBounded, low=BOUND_LOW, up=BOUND_UP, eta=20.0)
toolbox.register("mutate", tools.mutPolynomialBounded, low=BOUND_LOW, up=BOUND_UP, eta=20.0, indpb=1.0/NDIM)
toolbox.register("select", tools.selNSGA2)
Explanation: Describing attributes, individuals and population and defining the selection, mating and mutation operators.
End of explanation
toolbox.pop_size = 50
toolbox.max_gen = 500
toolbox.mut_prob = 0.2
Explanation: Let's also use the toolbox to store other configuration parameters of the algorithm. This will show itself usefull when performing massive experiments.
End of explanation
def nsga_ii(toolbox, stats=None, verbose=False):
pop = toolbox.population(n=toolbox.pop_size)
pop = toolbox.select(pop, len(pop))
return algorithms.eaMuPlusLambda(pop, toolbox, mu=toolbox.pop_size,
lambda_=toolbox.pop_size,
cxpb=1-toolbox.mut_prob,
mutpb=toolbox.mut_prob,
stats=stats,
ngen=toolbox.max_gen,
verbose=verbose)
Explanation: A compact NSGA-II implementation
Storing all the required information in the toolbox and using DEAP's algorithms.eaMuPlusLambda function allows us to create a very compact -albeit not a 100% exact copy of the original- implementation of NSGA-II.
End of explanation
%time res, logbook = nsga_ii(toolbox)
Explanation: Running the algorithm
We are now ready to run our NSGA-II.
End of explanation
fronts = tools.emo.sortLogNondominated(res, len(res))
Explanation: We can now get the Pareto fronts in the results (res).
End of explanation
plot_colors = ('b','r', 'g', 'm', 'y', 'k', 'c')
fig, ax = plt.subplots(1, figsize=(4,4))
for i,inds in enumerate(fronts):
par = [toolbox.evaluate(ind) for ind in inds]
df = pd.DataFrame(par)
df.plot(ax=ax, kind='scatter', label='Front ' + str(i+1),
x=df.columns[0], y=df.columns[1],
color=plot_colors[i % len(plot_colors)])
plt.xlabel('$f_1(\mathbf{x})$');plt.ylabel('$f_2(\mathbf{x})$');
Explanation: Resulting Pareto fronts
End of explanation
stats = tools.Statistics()
stats.register("pop", copy.deepcopy)
toolbox.max_gen = 4000 # we need more generations!
Explanation: It is better to make an animated plot of the evolution as it takes place.
Animating the evolutionary process
We create a stats to store the individuals not only their objective function values.
End of explanation
%time res, logbook = nsga_ii(toolbox, stats=stats)
from JSAnimation import IPython_display
import matplotlib.colors as colors
from matplotlib import animation
def animate(frame_index, logbook):
'Updates all plots to match frame _i_ of the animation.'
ax.clear()
fronts = tools.emo.sortLogNondominated(logbook.select('pop')[frame_index],
len(logbook.select('pop')[frame_index]))
for i,inds in enumerate(fronts):
par = [toolbox.evaluate(ind) for ind in inds]
df = pd.DataFrame(par)
df.plot(ax=ax, kind='scatter', label='Front ' + str(i+1),
x=df.columns[0], y =df.columns[1], alpha=0.47,
color=plot_colors[i % len(plot_colors)])
ax.set_title('$t=$' + str(frame_index))
ax.set_xlabel('$f_1(\mathbf{x})$');ax.set_ylabel('$f_2(\mathbf{x})$')
return None
fig = plt.figure(figsize=(4,4))
ax = fig.gca()
anim = animation.FuncAnimation(fig, lambda i: animate(i, logbook),
frames=len(logbook), interval=60,
blit=True)
anim
Explanation: Re-run the algorithm to get the data necessary for plotting.
End of explanation
anim.save('nsgaii-dtlz3.mp4', fps=15, bitrate=-1, dpi=500)
from IPython.display import YouTubeVideo
YouTubeVideo('Cm7r4cJq59s')
Explanation: The previous animation makes the notebook too big for online viewing. To circumvent this, it is better to save the animation as video and (manually) upload it to YouTube.
End of explanation
def dtlz5(ind, n_objs):
from functools import reduce
g = lambda x: sum([(a - 0.5)**2 for a in x])
gval = g(ind[n_objs-1:])
theta = lambda x: math.pi / (4.0 * (1 + gval)) * (1 + 2 * gval * x)
fit = [(1 + gval) * math.cos(math.pi / 2.0 * ind[0]) *
reduce(lambda x,y: x*y, [math.cos(theta(a)) for a in ind[1:]])]
for m in reversed(range(1, n_objs)):
if m == 1:
fit.append((1 + gval) * math.sin(math.pi / 2.0 * ind[0]))
else:
fit.append((1 + gval) * math.cos(math.pi / 2.0 * ind[0]) *
reduce(lambda x,y: x*y, [math.cos(theta(a)) for a in ind[1:m-1]], 1) *
math.sin(theta(ind[m-1])))
return fit
def dtlz6(ind, n_objs):
from functools import reduce
gval = sum([a**0.1 for a in ind[n_objs-1:]])
theta = lambda x: math.pi / (4.0 * (1 + gval)) * (1 + 2 * gval * x)
fit = [(1 + gval) * math.cos(math.pi / 2.0 * ind[0]) *
reduce(lambda x,y: x*y, [math.cos(theta(a)) for a in ind[1:]])]
for m in reversed(range(1, n_objs)):
if m == 1:
fit.append((1 + gval) * math.sin(math.pi / 2.0 * ind[0]))
else:
fit.append((1 + gval) * math.cos(math.pi / 2.0 * ind[0]) *
reduce(lambda x,y: x*y, [math.cos(theta(a)) for a in ind[1:m-1]], 1) *
math.sin(theta(ind[m-1])))
return fit
Explanation: Here it is clearly visible how the algorithm "jumps" from one local-optimum to a better one as evolution takes place.
MOP benchmark problem toolkits
Each problem instance is meant to test the algorithms with regard with a given feature: local optima, convexity, discontinuity, bias, or a combination of them.
ZDT1-6: Two-objective problems with a fixed number of decision variables.
E. Zitzler, K. Deb, and L. Thiele. Comparison of Multiobjective Evolutionary Algorithms: Empirical Results. Evolutionary Computation, 8(2):173-195, 2000. (pdf)
DTLZ1-7: $m$-objective problems with $n$ variables.
K. Deb, L. Thiele, M. Laumanns and E. Zitzler. Scalable Multi-Objective Optimization Test Problems. CEC 2002, p. 825 - 830, IEEE Press, 2002. (pdf)
CEC'09: Two- and three- objective problems that very complex Pareto sets.
Zhang, Q., Zhou, A., Zhao, S., & Suganthan, P. N. (2009). Multiobjective optimization test instances for the CEC 2009 special session and competition. In 2009 IEEE Congress on Evolutionary Computation (pp. 1–30). (pdf)
WFG1-9: $m$-objective problems with $n$ variables, very complex.
Huband, S., Hingston, P., Barone, L., & While, L. (2006). A review of multiobjective test problems and a scalable test problem toolkit. IEEE Transactions on Evolutionary Computation, 10(5), 477–506. doi:10.1109/TEVC.2005.861417
DTLZ5 and DTLZ6 have an $m-1$-dimensional Pareto-optimal front.
* This means that in 3D the Pareto optimal front is a 2D curve.
<div align='center'><img src='http://www.cs.cinvestav.mx/~emoobook/apendix-e/galeria4/dtlz5a.jpg' width="38%" align='center'/></div>
In two dimensions the front is a point.
End of explanation
def dtlz7(ind, n_objs):
gval = 1 + 9.0 / len(ind[n_objs-1:]) * sum([a for a in ind[n_objs-1:]])
fit = [ind for ind in ind[:n_objs-1]]
fit.append((1 + gval) * (n_objs - sum([a / (1.0 + gval) * (1 + math.sin(3 * math.pi * a)) for a in ind[:n_objs-1]])))
return fit
Explanation: DTLZ7 has many disconnected Pareto-optimal fronts.
<div align='center'><img src='http://www.cs.cinvestav.mx/~emoobook/apendix-e/galeria4/dtlz7b.jpg' width="38%" align='center'/></div>
End of explanation
problem_instances = {'ZDT1': benchmarks.zdt1, 'ZDT2': benchmarks.zdt2,
'ZDT3': benchmarks.zdt3, 'ZDT4': benchmarks.zdt4,
'DTLZ1': lambda ind: benchmarks.dtlz1(ind,2),
'DTLZ2': lambda ind: benchmarks.dtlz2(ind,2),
'DTLZ3': lambda ind: benchmarks.dtlz3(ind,2),
'DTLZ4': lambda ind: benchmarks.dtlz4(ind,2, 100),
'DTLZ5': lambda ind: dtlz5(ind,2),
'DTLZ6': lambda ind: dtlz6(ind,2),
'DTLZ7': lambda ind: dtlz7(ind,2)}
toolbox.max_gen = 1000
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("obj_vals", np.copy)
def run_problem(toolbox, problem):
toolbox.register('evaluate', problem)
return nsga_ii(toolbox, stats=stats)
Explanation: How does our NSGA-II behaves when faced with different benchmark problems?
End of explanation
%time results = {problem: run_problem(toolbox, problem_instances[problem]) \
for problem in problem_instances}
Explanation: Running NSGA-II solving all problems. Now it takes longer.
End of explanation
class MultiProblemAnimation:
def init(self, fig, results):
self.results = results
self.axs = [fig.add_subplot(3,4,i+1) for i in range(len(results))]
self.plots =[]
for i, problem in enumerate(sorted(results)):
(res, logbook) = self.results[problem]
pop = pd.DataFrame(data=logbook.select('obj_vals')[0])
plot = self.axs[i].plot(pop[0], pop[1], 'b.', alpha=0.47)[0]
self.plots.append(plot)
fig.tight_layout()
def animate(self, t):
'Updates all plots to match frame _i_ of the animation.'
for i, problem in enumerate(sorted(results)):
#self.axs[i].clear()
(res, logbook) = self.results[problem]
pop = pd.DataFrame(data=logbook.select('obj_vals')[t])
self.plots[i].set_data(pop[0], pop[1])
self.axs[i].set_title(problem + '; $t=' + str(t)+'$')
self.axs[i].set_xlim((0, max(1,pop.max()[0])))
self.axs[i].set_ylim((0, max(1,pop.max()[1])))
return self.axs
mpa = MultiProblemAnimation()
fig = plt.figure(figsize=(14,6))
anim = animation.FuncAnimation(fig, mpa.animate, init_func=mpa.init(fig,results),
frames=toolbox.max_gen, interval=60, blit=True)
anim
Explanation: Creating this animation takes more programming effort.
End of explanation
anim.save('nsgaii-benchmarks.mp4', fps=15, bitrate=-1, dpi=500)
YouTubeVideo('8t-aWcpDH0U')
Explanation: Saving the animation as video and uploading it to YouTube.
End of explanation
toolbox = base.Toolbox()
BOUND_LOW, BOUND_UP = 0.0, 1.0
NDIM = 30
# the explanation of this... a few lines bellow
def eval_helper(ind):
return benchmarks.dtlz3(ind, 2)
toolbox.register("evaluate", eval_helper)
def uniform(low, up, size=None):
try:
return [random.uniform(a, b) for a, b in zip(low, up)]
except TypeError:
return [random.uniform(a, b) for a, b in zip([low] * size, [up] * size)]
toolbox.register("attr_float", uniform, BOUND_LOW, BOUND_UP, NDIM)
toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.attr_float)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxSimulatedBinaryBounded, low=BOUND_LOW, up=BOUND_UP, eta=20.0)
toolbox.register("mutate", tools.mutPolynomialBounded, low=BOUND_LOW, up=BOUND_UP, eta=20.0, indpb=1.0/NDIM)
toolbox.register("select", tools.selNSGA2)
toolbox.pop_size = 200
toolbox.max_gen = 500
Explanation: It is interesting how the algorithm deals with each problem: clearly some problems are harder than others.
In some cases it "hits" the Pareto front and then slowly explores it.
Experiment design and reporting results
Watching an animation of an EMO algorithm solve a problem is certainly fun.
It also allows us to understand many particularities of the problem being solved.
But, as Carlos Coello would say, we are not in an art appreciation class.
We should follow the key concepts provided by the scientific method.
I urge you to study the experimental design topic in depth, as it is an essential knowledge.
<p>
<div class="alert alert-info" role="alert">
**Evolutionary algorithms are stochastic algorithms; therefore their results must be assessed by repeating experiments until you reach an statistically valid conclusion.**
</div>
</p>
We need to evaluate performance
Closeness to the Pareto-optimal front.
Diversity of solutions.
Coverage of the Pareto-optimal fronts.
<p>
<div class="alert alert-success" role="alert">
<span class="label label-success">Research hint!</span> The design analysis and application of performance indicators is one of the main research topic in the EMO field.</div>
</p>
The hypervolume indicator
<table align='center' width="92%">
<tr>
<td width='50%'>
<img src='https://ls11-www.cs.uni-dortmund.de/_media/rudolph/hypervolume/hv.png' width='92%'>
</td>
<td width='50%'>
<img src='https://ls11-www.cs.uni-dortmund.de/_media/rudolph/hypervolume/hvemm3d.png' width='92%'>
</td>
</tr>
</table>
Note: Taken from Günter Rudolph's site on the hypervolume indicator.
Formalization of the hypervolume
For a set of solutions $\mathcal{A}$,
$$
I_\mathrm{hyp}\left(\mathcal{A}\right) = \mathrm{volume}\left(
\bigcup_{\forall \mathbf{a}\in\mathcal{A}}{\mathrm{hypercube}(\mathbf{a},\mathbf{r})}\right)\,.
$$
We need a reference point, $\mathbf{r}$.
Hypervolume is Pareto compliant (Fleischer, 2003): for sets $\mathcal{A}$ and $\mathcal{B}$, $\mathcal{A}\preccurlyeq\mathcal{B} \implies I_\mathrm{hyp}(A)>I_\mathrm{hyp}(B)$.
Calculating hypervolume is #P-hard, i.e. superpolynomial runtime unless P = NP (Bringmann and Friedrich, 2008).
An illustrative simple/sample experiment
Let's make a relatively simple experiment:
Hypothesis: The mutation probability of NSGA-II matters when solving the DTLZ3 problem.
Procedure: We must perform an experiment testing different mutation probabilities while keeping the other parameters constant.
Notation
As usual we need to establish some notation:
Multi-objective problem (or just problem): A multi-objective optimization problem, as defined above.
MOEA: An evolutionary computation method used to solve multi-objective problems.
Experiment: a combination of problem and MOEA and a set of values of their parameters.
Experiment run: The result of running an experiment.
We will use toolbox instances to define experiments.
We start by creating a toolbox that will contain the configuration that will be shared across all experiments.
End of explanation
toolbox.experiment_name = "$P_\mathrm{mut}="
Explanation: We add a experiment_name to toolbox that we will fill up later on.
End of explanation
mut_probs = (0.05, 0.15, 0.3)
number_of_experiments = len(mut_probs)
toolboxes=list([copy.copy(toolbox) for _ in range(number_of_experiments)])
Explanation: We can now replicate this toolbox instance and then modify the mutation probabilities.
End of explanation
for i, toolbox in enumerate(toolboxes):
toolbox.mut_prob = mut_probs[i]
toolbox.experiment_name = toolbox.experiment_name + str(mut_probs[i]) +'$'
for toolbox in toolboxes:
print(toolbox.experiment_name, toolbox.mut_prob)
Explanation: Now toolboxes is a list of copies of the same toolbox. One for each experiment configuration (population size).
...but we still have to set the population sizes in the elements of toolboxes.
End of explanation
number_of_runs = 42
Explanation: Experiment design
As we are dealing with stochastic methods their results should be reported relying on an statistical analysis.
A given experiment (a toolbox instance in our case) should be repeated a sufficient amount of times.
In theory, the more runs the better, but how much in enough? In practice, we could say that about 30 runs is enough.
The non-dominated fronts produced by each experiment run should be compared to each other.
We have seen in class that a number of performance indicators, like the hypervolume, additive and multiplicative epsilon indicators, among others, have been proposed for that task.
We can use statistical visualizations like box plots or violin plots to make a visual assessment of the indicator values produced in each run.
We must apply a set of statistical hypothesis tests in order to reach an statistically valid judgment of the results of an algorithms.
Note: I personally like the number 42 as it is the answer to The Ultimate Question of Life, the Universe, and Everything.
End of explanation
from IPython.html import widgets
from IPython.display import display
progress_bar = widgets.IntProgressWidget(description="Starting...",
max=len(toolboxes)*number_of_runs)
Explanation: Running experiments in parallel
As we are now solving more demanding problems it would be nice to make our algorithms to run in parallel and profit from modern multi-core CPUs.
In DEAP it is very simple to parallelize an algorithm (if it has been properly programmed) by providing a parallel map() function throu the toolbox.
Local parallelization can be achieved using Python's multiprocessing or concurrent.futures modules.
Cluster parallelization can be achived using IPython Parallel or SCOOP, that seems to be recommended by the DEAP guys as it was part of it.
Note: You can have a very good summary about this issue in http://blog.liang2.tw/2014-handy-dist-computing/.
Progress feedback
Another issue with these long experiments has to do being patient.
A little bit of feedback on the experiment execution would be cool.
We can use the integer progress bar from IPython widgets and report every time an experiment run is finished.
End of explanation
def run_algo_wrapper(toolboox):
result,a = nsga_ii(toolbox)
pareto_sets = tools.emo.sortLogNondominated(result, len(result))
return pareto_sets[0]
Explanation: A side-effect of using process-based parallelization
Process-based parallelization based on multiprocessing requires that the parameters passed to map() be pickleable.
The direct consequence is that lambda functions can not be directly used.
This is will certainly ruin the party to all lambda fans out there! -me included.
Hence we need to write some wrapper functions instead.
But, that wrapper function can take care of filtering out dominated individuals in the results.
End of explanation
%%time
from multiprocessing import Pool
display(progress_bar)
results = {}
pool = Pool()
for toolbox in toolboxes:
results[toolbox.experiment_name] = pool.map(run_algo_wrapper, [toolbox] * number_of_runs)
progress_bar.value +=number_of_runs
progress_bar.description = "Finished %03d of %03d:" % (progress_bar.value, progress_bar.max)
Explanation: All set! Run the experiments...
End of explanation
import pickle
pickle.dump(results, open('nsga_ii_dtlz3-results.pickle', 'wb'))
Explanation: As you can see, even this relatively small experiment took lots of time!
As running the experiments takes so long, lets save the results so we can use them whenever we want.
End of explanation
loaded_results = pickle.load(open('nsga_ii_dtlz3-results.pickle', 'rb'))
results = loaded_results # <-- (un)comment when needed
Explanation: In case you need it, this file is included in the github repository.
To load the results we would just have to:
End of explanation
res = pd.DataFrame(results)
res.head()
Explanation: results is a dictionary, but a pandas DataFrame is a more handy container for the results.
End of explanation
a = res.applymap(lambda pop: [toolbox.evaluate(ind) for ind in pop])
plt.figure(figsize=(11,3))
for i, col in enumerate(a.columns):
plt.subplot(1, len(a.columns), i+1)
for pop in a[col]:
x = pd.DataFrame(data=pop)
plt.scatter(x[0], x[1], marker='.', alpha=0.5)
plt.title(col)
Explanation: A first glace at the results
End of explanation
def calculate_reference(results, epsilon=0.1):
alldata = np.concatenate(np.concatenate(results.values))
obj_vals = [toolbox.evaluate(ind) for ind in alldata]
return np.max(obj_vals, axis=0) + epsilon
reference = calculate_reference(res)
reference
Explanation: The local Pareto-optimal fronts are clearly visible!
Calculating performance indicators
As already mentioned, we need to evaluate the quality of the solutions produced in every execution of the algorithm.
We will use the hypervolumne indicator for that.
We already filtered each population a leave only the non-dominated individuals.
Calculating the reference point: a point that is “worst” than any other individual in every objective.
End of explanation
import deap.benchmarks.tools as bt
hypervols = res.applymap(lambda pop: bt.hypervolume(pop, reference))
hypervols.head()
Explanation: We can now compute the hypervolume of the Pareto-optimal fronts yielded by each algorithm run.
End of explanation
hypervols.describe()
Explanation: How can we interpret the indicators?
Option A: Tabular form
End of explanation
import seaborn
seaborn.set(style="whitegrid")
fig = plt.figure(figsize=(15,3))
plt.subplot(1,2,1, title='Violin plots of NSGA-II with $P_{\mathrm{mut}}$')
seaborn.violinplot(hypervols, alpha=0.74)
plt.ylabel('Hypervolume'); plt.xlabel('Mutation probabilities')
plt.subplot(1,2,2, title='Box plots of NSGA-II with $P_{\mathrm{mut}}$')
seaborn.boxplot(hypervols, alpha=0.74)
plt.ylabel('Hypervolume'); plt.xlabel('Mutation probabilities');
Explanation: Option B: Visualization
End of explanation
import itertools
import scipy.stats as stats
def compute_stat_matrix(data, stat_func, alpha=0.05):
'''A function that applies `stat_func` to all combinations of columns in `data`.
Returns a squared matrix with the p-values'''
p_values = pd.DataFrame(columns=data.columns, index=data.columns)
for a,b in itertools.combinations(data.columns,2):
s,p = stat_func(data[a], data[b])
p_values[a].ix[b] = p
p_values[b].ix[a] = p
return p_values
Explanation: Option C: Statistical hypothesis test
Choosing the correct statistical test is essential to properly report the results.
Nonparametric statistics can lend a helping hand.
Parametric statistics could be a better choice in some cases.
Parametric statistics require that all data follow a known distribution (frequently a normal one).
Some tests -like the normality test- can be apply to verify that data meet the parametric stats requirements.
In my experience that is very unlikely that all your EMO result meet those characteristics.
We start by writing a function that helps us tabulate the results of the application of an statistical hypothesis test.
End of explanation
stats.kruskal(*[hypervols[col] for col in hypervols.columns])
Explanation: The Kruskal-Wallis H-test tests the null hypothesis that the population median of all of the groups are equal.
It is a non-parametric version of ANOVA.
The test works on 2 or more independent samples, which may have different sizes.
Note that rejecting the null hypothesis does not indicate which of the groups differs.
Post-hoc comparisons between groups are required to determine which groups are different.
End of explanation
def conover_inman_procedure(data, alpha=0.05):
num_runs = len(data)
num_algos = len(data.columns)
N = num_runs*num_algos
_,p_value = stats.kruskal(*[data[col] for col in data.columns])
ranked = stats.rankdata(np.concatenate([data[col] for col in data.columns]))
ranksums = []
for i in range(num_algos):
ranksums.append(np.sum(ranked[num_runs*i:num_runs*(i+1)]))
S_sq = (np.sum(ranked**2) - N*((N+1)**2)/4)/(N-1)
right_side = stats.t.cdf(1-(alpha/2), N-num_algos) * \
math.sqrt((S_sq*((N-1-p_value)/(N-1)))*2/num_runs)
res = pd.DataFrame(columns=data.columns, index=data.columns)
for i,j in itertools.combinations(np.arange(num_algos),2):
res[res.columns[i]].ix[j] = abs(ranksums[i] - ranksums[j]/num_runs) > right_side
res[res.columns[j]].ix[i] = abs(ranksums[i] - ranksums[j]/num_runs) > right_side
return res
conover_inman_procedure(hypervols)
Explanation: We now can assert that the results are not the same but which ones are different or similar to the others the others?
In case that the null hypothesis of the Kruskal-Wallis is rejected the Conover–Inman procedure (Conover, 1999, pp. 288-290) can be applied in a pairwise manner in order to determine if the results of one algorithm were significantly better than those of the other.
Conover, W. J. (1999). Practical Nonparametric Statistics. John Wiley & Sons, New York, 3rd edition.
Note: If you want to get an extended summary of this method check out my PhD thesis.
End of explanation
hyp_transp = hypervols.transpose()
measurements = [list(hyp_transp[col]) for col in hyp_transp.columns]
stats.friedmanchisquare(*measurements)
Explanation: We now know in what cases the difference is sufficient as to say that one result is better than the other.
Another alternative is the Friedman test.
Its null hypothesis that repeated measurements of the same individuals have the same distribution.
It is often used to test for consistency among measurements obtained in different ways.
For example, if two measurement techniques are used on the same set of individuals, the Friedman test can be used to determine if the two measurement techniques are consistent.
End of explanation
raw_p_values=compute_stat_matrix(hypervols, stats.mannwhitneyu)
raw_p_values
Explanation: Mann–Whitney U test (also called the Mann–Whitney–Wilcoxon (MWW), Wilcoxon rank-sum test (WRS), or Wilcoxon–Mann–Whitney test) is a nonparametric test of the null hypothesis that two populations are the same against an alternative hypothesis, especially that a particular population tends to have larger values than the other.
It has greater efficiency than the $t$-test on non-normal distributions, such as a mixture of normal distributions, and it is nearly as efficient as the $t$-test on normal distributions.
End of explanation
from scipy.misc import comb
alpha=0.05
alpha_sid = 1 - (1-alpha)**(1/comb(len(hypervols.columns), 2))
alpha_sid
Explanation: The familywise error rate (FWER) is the probability of making one or more false discoveries, or type I errors, among all the hypotheses when performing multiple hypotheses tests.
Example: When performing a test, there is a $\alpha$ chance of making a type I error. If we make $m$ tests, then the probability of making one type I error is $m\alpha$. Therefore, if an $\alpha=0.05$ is used and 5 pairwise comparisons are made, we will have a $5\times0.05 = 0.25$ chance of making a type I error.
FWER procedures (such as the Bonferroni correction) exert a more stringent control over false discovery compared to False discovery rate controlling procedures.
FWER controlling seek to reduce the probability of even one false discovery, as opposed to the expected proportion of false discoveries.
Thus, FDR procedures have greater power at the cost of increased rates of type I errors, i.e., rejecting the null hypothesis of no effect when it should be accepted.
One of these corrections is the Šidák correction as it is less conservative than the Bonferroni correction:
$$\alpha_{SID} = 1-(1-\alpha)^\frac{1}{m},$$
where $m$ is the number of tests.
In our case $m$ is the number of combinations of algorithm configurations taken two at a time.
There are other corrections that can be used.
End of explanation
raw_p_values.applymap(lambda value: value <= alpha_sid)
Explanation: Let's apply the corrected alpha to raw_p_values. If we have a cell with a True value that means that those two results are the same.
End of explanation |
3,463 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
In this notebook we will work through a representational similarity analysis of the Haxby dataset.
Step1: Let's ask the following question
Step2: Let's test whether similarity is higher for faces across runs within-condition versus similarity between faces and all other categories. Note that we would generally want to compute this for each subject and do statistics on the means across subjects, rather than computing the statistics within-subject as we do below (which treats subject as a fixed effect) | Python Code:
import numpy
import nibabel
import os
from haxby_data import HaxbyData
from nilearn.input_data import NiftiMasker
%matplotlib inline
import matplotlib.pyplot as plt
import sklearn.manifold
import scipy.cluster.hierarchy
datadir='/Users/poldrack/data_unsynced/haxby/subj1'
print 'Using data from',datadir
haxbydata=HaxbyData(datadir)
modeldir=os.path.join(datadir,'blockmodel')
try:
os.chdir(modeldir)
except:
print 'problem changing to',modeldir
print 'you may need to run the Classification Analysis script first'
use_whole_brain=False
if use_whole_brain:
maskimg=haxbydata.brainmaskfile
else:
maskimg=haxbydata.vtmaskfile
nifti_masker = NiftiMasker(mask_img=maskimg, standardize=False)
fmri_masked = nifti_masker.fit_transform(os.path.join(modeldir,'zstatdata.nii.gz'))
Explanation: In this notebook we will work through a representational similarity analysis of the Haxby dataset.
End of explanation
cc=numpy.zeros((8,8,12,12))
# loop through conditions
for ci in range(8):
for cj in range(8):
for i in range(12):
for j in range(12):
idx_i=numpy.where(numpy.logical_and(haxbydata.runs==i,haxbydata.condnums==ci+1))[0][0]
idx_j=numpy.where(numpy.logical_and(haxbydata.runs==j,haxbydata.condnums==cj+1))[0][0]
cc[ci,cj,i,j]=numpy.corrcoef(fmri_masked[idx_i,:],fmri_masked[idx_j,:])[0,1]
for ci in range(8):
for cj in range(8):
cci=cc[ci,cj,:,:]
meansim[ci,cj]=numpy.mean(numpy.hstack((cci[numpy.triu_indices(12,1)],
cci[numpy.tril_indices(12,1)])))
plt.imshow(meansim,interpolation='nearest')
l=scipy.cluster.hierarchy.ward(1.0 - meansim)
cl=scipy.cluster.hierarchy.dendrogram(l,labels=haxbydata.condlabels,orientation='right')
Explanation: Let's ask the following question: Are cats (condition 3) more similar to human faces (condition 2) than to chairs (condition 8)? To do this, we compute the between-run similarity for all conditions against each other.
End of explanation
# within-condition
face_corr={}
corr_means=[]
corr_stderr=[]
corr_stimtype=[]
for k in haxbydata.cond_dict.iterkeys():
face_corr[k]=[]
for i in range(12):
for j in range(12):
if i==j:
continue
face_corr[k].append(cc[haxbydata.cond_dict['face']-1,haxbydata.cond_dict[k]-1,i,j])
corr_means.append(numpy.mean(face_corr[k]))
corr_stderr.append(numpy.std(face_corr[k])/numpy.sqrt(len(face_corr[k])))
corr_stimtype.append(k)
idx=numpy.argsort(corr_means)[::-1]
plt.bar(numpy.arange(0.5,8.),[corr_means[i] for i in idx],yerr=[corr_stderr[i] for i in idx]) #,yerr=corr_sterr[idx])
t=plt.xticks(numpy.arange(1,9), [corr_stimtype[i] for i in idx],rotation=70)
plt.ylabel('Mean between-run correlation with faces')
import sklearn.manifold
mds=sklearn.manifold.MDS()
#mds=sklearn.manifold.TSNE(early_exaggeration=10,perplexity=70,learning_rate=100,n_iter=5000)
encoding=mds.fit_transform(fmri_masked)
plt.figure(figsize=(12,12))
ax=plt.axes() #[numpy.min(encoding[0]),numpy.max(encoding[0]),numpy.min(encoding[1]),numpy.max(encoding[1])])
ax.scatter(encoding[:,0],encoding[:,1])
offset=0.01
for i in range(encoding.shape[0]):
ax.annotate(haxbydata.conditions[i].split('-')[0],(encoding[i,0],encoding[i,1]),xytext=[encoding[i,0]+offset,encoding[i,1]+offset])
#for i in range(encoding.shape[0]):
# plt.text(encoding[i,0],encoding[i,1],'%d'%haxbydata.condnums[i])
mdsmeans=numpy.zeros((2,8))
for i in range(8):
mdsmeans[:,i]=numpy.mean(encoding[haxbydata.condnums==(i+1),:],0)
for i in range(2):
print 'Dimension %d:'%int(i+1)
idx=numpy.argsort(mdsmeans[i,:])
for j in idx:
print '%s:\t%f'%(haxbydata.condlabels[j],mdsmeans[i,j])
print ''
Explanation: Let's test whether similarity is higher for faces across runs within-condition versus similarity between faces and all other categories. Note that we would generally want to compute this for each subject and do statistics on the means across subjects, rather than computing the statistics within-subject as we do below (which treats subject as a fixed effect)
End of explanation |
3,464 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Brainstorm CTF phantom tutorial dataset
Here we compute the evoked from raw for the Brainstorm CTF phantom
tutorial dataset. For comparison, see [1]_ and
Step1: The data were collected with a CTF system at 2400 Hz.
Step2: The sinusoidal signal is generated on channel HDAC006, so we can use
that to obtain precise timing.
Step3: Let's create some events using this signal by thresholding the sinusoid.
Step4: The CTF software compensation works reasonably well
Step5: But here we can get slightly better noise suppression, lower localization
bias, and a better dipole goodness of fit with spatio-temporal (tSSS)
Maxwell filtering
Step6: Our choice of tmin and tmax should capture exactly one cycle, so
we can make the unusual choice of baselining using the entire epoch
when creating our evoked data. We also then crop to a single time point
(@t=0) because this is a peak in our signal.
Step7: Let's use a sphere head geometry model and let's see the coordinate
alignement and the sphere location.
Step8: To do a dipole fit, let's use the covariance provided by the empty room
recording.
Step9: Compare the actual position with the estimated one. | Python Code:
# Authors: Eric Larson <[email protected]>
#
# License: BSD (3-clause)
import os.path as op
import numpy as np
import matplotlib.pyplot as plt
import mne
from mne import fit_dipole
from mne.datasets.brainstorm import bst_phantom_ctf
from mne.io import read_raw_ctf
print(__doc__)
Explanation: Brainstorm CTF phantom tutorial dataset
Here we compute the evoked from raw for the Brainstorm CTF phantom
tutorial dataset. For comparison, see [1]_ and:
http://neuroimage.usc.edu/brainstorm/Tutorials/PhantomCtf
References
.. [1] Tadel F, Baillet S, Mosher JC, Pantazis D, Leahy RM.
Brainstorm: A User-Friendly Application for MEG/EEG Analysis.
Computational Intelligence and Neuroscience, vol. 2011, Article ID
879716, 13 pages, 2011. doi:10.1155/2011/879716
End of explanation
data_path = bst_phantom_ctf.data_path()
# Switch to these to use the higher-SNR data:
# raw_path = op.join(data_path, 'phantom_200uA_20150709_01.ds')
# dip_freq = 7.
raw_path = op.join(data_path, 'phantom_20uA_20150603_03.ds')
dip_freq = 23.
erm_path = op.join(data_path, 'emptyroom_20150709_01.ds')
raw = read_raw_ctf(raw_path, preload=True)
Explanation: The data were collected with a CTF system at 2400 Hz.
End of explanation
sinusoid, times = raw[raw.ch_names.index('HDAC006-4408')]
plt.figure()
plt.plot(times[times < 1.], sinusoid.T[times < 1.])
Explanation: The sinusoidal signal is generated on channel HDAC006, so we can use
that to obtain precise timing.
End of explanation
events = np.where(np.diff(sinusoid > 0.5) > 0)[1] + raw.first_samp
events = np.vstack((events, np.zeros_like(events), np.ones_like(events))).T
Explanation: Let's create some events using this signal by thresholding the sinusoid.
End of explanation
raw.plot()
Explanation: The CTF software compensation works reasonably well:
End of explanation
raw.apply_gradient_compensation(0) # must un-do software compensation first
mf_kwargs = dict(origin=(0., 0., 0.), st_duration=10.)
raw = mne.preprocessing.maxwell_filter(raw, **mf_kwargs)
raw.plot()
Explanation: But here we can get slightly better noise suppression, lower localization
bias, and a better dipole goodness of fit with spatio-temporal (tSSS)
Maxwell filtering:
End of explanation
tmin = -0.5 / dip_freq
tmax = -tmin
epochs = mne.Epochs(raw, events, event_id=1, tmin=tmin, tmax=tmax,
baseline=(None, None))
evoked = epochs.average()
evoked.plot()
evoked.crop(0., 0.)
Explanation: Our choice of tmin and tmax should capture exactly one cycle, so
we can make the unusual choice of baselining using the entire epoch
when creating our evoked data. We also then crop to a single time point
(@t=0) because this is a peak in our signal.
End of explanation
sphere = mne.make_sphere_model(r0=(0., 0., 0.), head_radius=None)
mne.viz.plot_alignment(raw.info, subject='sample',
meg='helmet', bem=sphere, dig=True,
surfaces=['brain'])
del raw, epochs
Explanation: Let's use a sphere head geometry model and let's see the coordinate
alignement and the sphere location.
End of explanation
raw_erm = read_raw_ctf(erm_path).apply_gradient_compensation(0)
raw_erm = mne.preprocessing.maxwell_filter(raw_erm, coord_frame='meg',
**mf_kwargs)
cov = mne.compute_raw_covariance(raw_erm)
del raw_erm
dip, residual = fit_dipole(evoked, cov, sphere)
Explanation: To do a dipole fit, let's use the covariance provided by the empty room
recording.
End of explanation
expected_pos = np.array([18., 0., 49.])
diff = np.sqrt(np.sum((dip.pos[0] * 1000 - expected_pos) ** 2))
print('Actual pos: %s mm' % np.array_str(expected_pos, precision=1))
print('Estimated pos: %s mm' % np.array_str(dip.pos[0] * 1000, precision=1))
print('Difference: %0.1f mm' % diff)
print('Amplitude: %0.1f nAm' % (1e9 * dip.amplitude[0]))
print('GOF: %0.1f %%' % dip.gof[0])
Explanation: Compare the actual position with the estimated one.
End of explanation |
3,465 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
run this notebook after running the RUN_SCRIPTS notebook.
output written to case name folder within the reports folder
Step1: populate the ds_dict (dictionary) with calculated datasets
Step2: read the settings, attribute, and color dictionaries
Step3: generate two excel report workbooks
Step4: generate average retirement attribute charts
Step5: generate annual average attribute charts for all active employees
Step6: generate spreadsheet report on months in job differential and pay differential | Python Code:
%%time
import pandas as pd
import functions as f
import reports as rp
Explanation: run this notebook after running the RUN_SCRIPTS notebook.
output written to case name folder within the reports folder
End of explanation
%%time
ds_dict = f.load_datasets()
Explanation: populate the ds_dict (dictionary) with calculated datasets
End of explanation
%%time
sdict = pd.read_pickle('dill/dict_settings.pkl')
adict = pd.read_pickle('dill/dict_attr.pkl')
cdict = pd.read_pickle('dill/dict_color.pkl')
Explanation: read the settings, attribute, and color dictionaries
End of explanation
%%time
# spreadsheets are located within the reports folder
# ret_stats.xlsx and annual_stats.xlsx
rp.stats_to_excel(ds_dict)
Explanation: generate two excel report workbooks:
End of explanation
%%time
# generating many charts...may take a little while
rp.retirement_charts(ds_dict, adict, cdict)
Explanation: generate average retirement attribute charts
End of explanation
%%time
# generating many charts...may take a little while
rp.annual_charts(ds_dict, adict, cdict)
Explanation: generate annual average attribute charts for all active employees
End of explanation
%%time
# this may take some time to complete due to color formatting
rp.job_diff_to_excel('standalone', 'p1', ds_dict)
Explanation: generate spreadsheet report on months in job differential and pay differential
End of explanation |
3,466 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Computing <a href="https
Step1: The unit circle $U$ is defined as the set
$$U
Step2: Given a list $L = [x_1, \cdots, x_n]$, the function $\texttt{std_and_mean}(L)$ computes the pair $(\mu, \sigma)$, where $\sigma$ is the sample standard deviation of $L$,
while $\mu$ is the mean of $L$. $\mu$ and $\sigma$ are defined as follows
Step3: The method $\texttt{confidence_interval}(k, n)$ runs $k$ approximations of $\pi$ using $n$ trials in each approximation run.
It computes a $97.3\%$ confidence interval for the value of $\pi$. | Python Code:
import random as rnd
import math
Explanation: Computing <a href="https://en.wikipedia.org/wiki/Pi">$\pi$</a> with the Monte-Carlo-Method
End of explanation
def approximate_pi(n):
k = 0
for _ in range(n):
x = 2 * rnd.random() - 1
y = 2 * rnd.random() - 1
r = x * x + y * y
if r <= 1:
k += 1
return 4 * k / n
Explanation: The unit circle $U$ is defined as the set
$$U := \bigl{ (x,y) \in \mathbb{R}^2 \bigm| x^2 + y^2 \leq 1 \bigr}.$$
The set $U$ contains those points $(x,y)$ that have distance of $1$ or less from the origin
$(0,0)$. The unit circle is a subset of the square $Q$ that is defined as
$$Q := \bigl{ (x,y) \in \mathbb{R}^2 \bigm| -1 \leq x \leq +1 \wedge -1 \leq y \leq +1 \bigr}.$$
A simple algorithm to compute $\pi$ works as follows: We randomly create $n$ points $(x,y) \in Q$.
Then we count the number of points that end up in the unit circle $U$. Call this number $k$.
It is reasonable to assume that approximately $k$ is to $n$ as the area of $U$ is to the area of $Q$. As the area of $Q$ is
$2 \cdot 2$ and the area of $U$ equals $\pi \cdot 1^2$, we should have
$$\frac{k}{n} \approx \frac{\pi}{4}.$$
Multiplying by $4$ we get
$$\pi \approx 4 \cdot \frac{k}{n}.$$
The function $\texttt{approximate_pi}(n)$ creates $n$ random points in $Q$ and approximates $\pi$ as $4 \cdot \frac{k}{n}$.
End of explanation
def std_and_mean(L):
N = len(L)
mean = sum(L) / N
ss = 0
for x in L:
ss += (x - mean) ** 2
ss /= (N - 1)
std = math.sqrt(ss)
return mean, std
Explanation: Given a list $L = [x_1, \cdots, x_n]$, the function $\texttt{std_and_mean}(L)$ computes the pair $(\mu, \sigma)$, where $\sigma$ is the sample standard deviation of $L$,
while $\mu$ is the mean of $L$. $\mu$ and $\sigma$ are defined as follows:
$$ \mu = \sum\limits_{i=1}^n x_i$$
$$ \sigma = \sqrt{\sum\limits_{i=1}^n \frac{(x_i - \mu)^2}{N-1}} $$
End of explanation
def confidence_interval(k, n):
L = []
for _ in range(k):
L.append(approximate_pi(n))
𝜇, 𝜎 = std_and_mean(L)
return 𝜇 - 3 * 𝜎, 𝜇, 𝜇 + 3 * 𝜎
%%time
n = 100
while n <= 10000000:
lower, pi, upper = confidence_interval(100, n)
print('%9d: %6f < 𝜋 < %6f, 𝜋 ≈ %6f, error: %6f' % (n, lower, upper, pi, abs(pi - math.pi)))
n *= 10
Explanation: The method $\texttt{confidence_interval}(k, n)$ runs $k$ approximations of $\pi$ using $n$ trials in each approximation run.
It computes a $97.3\%$ confidence interval for the value of $\pi$.
End of explanation |
3,467 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Exercici
Step1: Programa principal
Substituïu els comentaris per les ordres necessàries
Step2: Ha funcionat a la primera? Fer un quadrat perfecte no és fàcil, i el més normal és que calga ajustar un parell de coses
Step3: És important que les instruccions de dins del bucle estiguen desplaçades cap a la dreta, és a dir indentades.
Substituïu els comentaris per les instruccions i proveu.
Recapitulem
Per a acabar l'exercici, i abans de passar a la següent pàgina, desconnecteu el robot | Python Code:
from functions import connect, forward, stop, left, right, disconnect, next_notebook
from time import sleep
connect() # Executeu, polsant Majúscules + Enter
Explanation: Exercici: fer un quadrat
<img src="img/bart-simpson-chalkboard.jpg" align="right" width=250>
A partir de les instruccions dels moviments bàsics, heu de fer un programa per a que el robot avance i gire 90 graus, de manera de faça una trajectòria quadrada.
L'estratègia és simple: repetiu quatre vegades el codi necessari per a fer avançar el robot un temps, i girar (a l'esquerra o a la dreta).
Abans que res, no oblideu connectar-vos al robot!
End of explanation
# avançar
# girar
# avançar
# girar
# avançar
# girar
# avançar
# girar
# parar
Explanation: Programa principal
Substituïu els comentaris per les ordres necessàries:
End of explanation
for i in range(4):
# avançar
# girar
# parar
Explanation: Ha funcionat a la primera? Fer un quadrat perfecte no és fàcil, i el més normal és que calga ajustar un parell de coses:
el gir de 90 graus: si el robot gira massa, heu de disminuir el temps del sleep; si gira massa poc, augmentar-lo (podeu posar decimals)
si no va recte: és normal que un dels motors gire una mica més ràpid que l'altre; podeu ajustar les velocitats de cada motor individualment entre 0 (mínim) i 100 (màxim), per exemple:
forward(speed_B=90,speed_C=75)
Canvieu els valors i torneu a provar fins aconseguir un quadrat decent (la perfecció és impossible).
Versió pro
Els llenguatges de programació tenen estructures per a repetir blocs d'instruccions sense haver d'escriure-les tantes vegades. És el que s'anomena bucle o, en anglès, for loop.
En Python, un bucle per a repetir un bloc d'instruccions quatre vegades s'escriu així:
End of explanation
disconnect()
next_notebook('sensors')
Explanation: És important que les instruccions de dins del bucle estiguen desplaçades cap a la dreta, és a dir indentades.
Substituïu els comentaris per les instruccions i proveu.
Recapitulem
Per a acabar l'exercici, i abans de passar a la següent pàgina, desconnecteu el robot:
End of explanation |
3,468 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
DiscontinuityDetector use example
This algorithm uses LPC and some heuristics to detect discontinuities in anaudio signal. [1].
References
Step1: Generating some discontinuities examples
Let's start by degrading some audio files with some discontinuities. Discontinuities are generally occasioned by hardware issues in the process of recording or copying. Let's simulate this by removing a random number of samples from the input audio file.
Step2: Lets listen to the clip to have an idea on how audible the discontinuities are
Step3: The algorithm
This algorithm outputs the starts and ends timestapms of the clicks. The following plots show how the algorithm performs in the previous examples | Python Code:
import essentia.standard as es
import numpy as np
import matplotlib.pyplot as plt
from IPython.display import Audio
from essentia import array as esarr
plt.rcParams["figure.figsize"] =(12,9)
def compute(x, frame_size=1024, hop_size=512, **kwargs):
discontinuityDetector = es.DiscontinuityDetector(frameSize=frame_size,
hopSize=hop_size,
**kwargs)
locs = []
amps = []
for idx, frame in enumerate(es.FrameGenerator(x, frameSize=frame_size,
hopSize=hop_size, startFromZero=True)):
frame_locs, frame_ampls = discontinuityDetector(frame)
for l in frame_locs:
locs.append((l + hop_size * idx) / 44100.)
for a in frame_ampls:
amps.append(a)
return locs, amps
Explanation: DiscontinuityDetector use example
This algorithm uses LPC and some heuristics to detect discontinuities in anaudio signal. [1].
References:
[1] Mühlbauer, R. (2010). Automatic Audio Defect Detection.
End of explanation
def testRegression(self, frameSize=512, hopSize=256):
fs = 44100
audio = MonoLoader(filename=join(testdata.audio_dir,
'recorded/cat_purrrr.wav'),
sampleRate=fs)()
originalLen = len(audio)
startJump = originalLen / 4
groundTruth = [startJump / float(fs)]
# make sure that the artificial jump produces a prominent discontinuity
if audio[startJump] > 0:
end = next(idx for idx, i in enumerate(audio[startJump:]) if i < -.3)
else:
end = next(idx for idx, i in enumerate(audio[startJump:]) if i > .3)
endJump = startJump + end
audio = esarr(np.hstack([audio[:startJump], audio[endJump:]]))
frameList = []
discontinuityDetector = self.InitDiscontinuityDetector(
frameSize=frameSize, hopSize=hopSize,
detectionThreshold=10)
for idx, frame in enumerate(FrameGenerator(
audio, frameSize=frameSize,
hopSize=hopSize, startFromZero=True)):
locs, _ = discontinuityDetector(frame)
if not len(locs) == 0:
for loc in locs:
frameList.append((idx * hopSize + loc) / float(fs))
self.assertAlmostEqualVector(frameList, groundTruth, 1e-7)
fs = 44100.
audio_dir = '../../audio/'
audio = es.MonoLoader(filename='{}/{}'.format(audio_dir,
'recorded/vignesh.wav'),
sampleRate=fs)()
originalLen = len(audio)
startJumps = np.array([originalLen / 4, originalLen / 2])
groundTruth = startJumps / float(fs)
for startJump in startJumps:
# make sure that the artificial jump produces a prominent discontinuity
if audio[startJump] > 0:
end = next(idx for idx, i in enumerate(audio[startJump:]) if i < -.3)
else:
end = next(idx for idx, i in enumerate(audio[startJump:]) if i > .3)
endJump = startJump + end
audio = esarr(np.hstack([audio[:startJump], audio[endJump:]]))
for point in groundTruth:
l1 = plt.axvline(point, color='g', alpha=.5)
times = np.linspace(0, len(audio) / fs, len(audio))
plt.plot(times, audio)
plt.title('Signal with artificial clicks of different amplitudes')
l1.set_label('Click locations')
plt.legend()
Explanation: Generating some discontinuities examples
Let's start by degrading some audio files with some discontinuities. Discontinuities are generally occasioned by hardware issues in the process of recording or copying. Let's simulate this by removing a random number of samples from the input audio file.
End of explanation
Audio(audio, rate=fs)
Explanation: Lets listen to the clip to have an idea on how audible the discontinuities are
End of explanation
locs, amps = compute(audio)
fig, ax = plt.subplots(len(groundTruth))
plt.subplots_adjust(hspace=.4)
for idx, point in enumerate(groundTruth):
l1 = ax[idx].axvline(locs[idx], color='r', alpha=.5)
l2 = ax[idx].axvline(point, color='g', alpha=.5)
ax[idx].plot(times, audio)
ax[idx].set_xlim([point-.001, point+.001])
ax[idx].set_title('Click located at {:.2f}s'.format(point))
fig.legend((l1, l2), ('Detected discontinuity', 'Ground truth'), 'upper right')
Explanation: The algorithm
This algorithm outputs the starts and ends timestapms of the clicks. The following plots show how the algorithm performs in the previous examples
End of explanation |
3,469 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Benford for Python
Current version
Step1: Quick start
Getting some public data, the S&P500 EFT quotes, up until Dec 2016
Step2: Creating simple and log return columns
Step3: First Digits Test
Let us see if the SPY log retunrs conform to Benford's Law
Step4: The first_digits function draws the plot (default) with bars fot the digits found frequencies and a line corresponding to the expected Benford proportions.
It also returns a DataFrame object with Counts, Found proportions and Expected values for each digit in the data studied.
Step5: First Two Digists
Step6: Assessing conformity
There are some tests to more precisely evaluate if the data studied is a good fit to Benford's Law.
The first we'll use is the Z statistic for the proportions.
In the digits functions, you can turn it on by settign the parameter confidence, which will tell the function which confidence level to consider after calculating the Z score for each proportion.
Step7: Some things happened
Step8: There are also the Second Digit test, and Last Two Digits test, as shown bellow.
Step9: Other Important Parameters
<li>digs
Step10: Note that you must choose the test parameter, since there is one MAD for each test.
<li>First Digit
Step11: Or you can set the MAD parameter to True when running the tests functions, and it will also give the corresponding conformity limits (as long as inform is also True).
Step12: Mantissas
The mantissa is the decimal part of a logarithm. In a Benford data set, the mantissas of the registries' logs are uniformly distributed, such that when ordered,they should form a straight line in the interval [0,1), with slope 1/N, N being the sample size.. | Python Code:
%matplotlib inline
import numpy as np
import pandas as pd
#import pandas_datareader.data as web # Not a dependency, but we'll need it now.
import benford as bf
Explanation: Benford for Python
Current version: 0.1.0.3
Installation
As of Dec 2017, Benford for python is a Package in PyPi, so you can install with pip:
$ pip install benford_py
Or you can cd into the site-packages subfolder of your python distribution (or environment) and clone from there:
$ git clone http://github.com/milcent/Benford_py.git.
Demo
This demo assumes you have (at least) some familiarity with Benford's Law.
First let's import some libraries and the benford module.
End of explanation
sp = pd.read_csv('data/SPY.csv', index_col='Date', parse_dates=True)
Explanation: Quick start
Getting some public data, the S&P500 EFT quotes, up until Dec 2016
End of explanation
#adding '_' to facilitate handling the column
#sp.rename(columns={'Adj Close':'Adj_Close'}, inplace=True)
sp['p_r'] = sp.Close/sp.Close.shift()-1 #simple returns
sp['l_r'] = np.log(sp.Close/sp.Close.shift()) #log returns
sp.tail()
Explanation: Creating simple and log return columns
End of explanation
f1d = bf.first_digits(sp.l_r, digs=1, decimals=8) # digs=1 for the first digit (1-9)
Explanation: First Digits Test
Let us see if the SPY log retunrs conform to Benford's Law
End of explanation
f1d
Explanation: The first_digits function draws the plot (default) with bars fot the digits found frequencies and a line corresponding to the expected Benford proportions.
It also returns a DataFrame object with Counts, Found proportions and Expected values for each digit in the data studied.
End of explanation
f2d = bf.first_digits(sp.l_r, digs=2, decimals=8) # Note the parameter digs=2!
f2d.head()
f2d.tail()
Explanation: First Two Digists
End of explanation
# For a significance of 5%, a confidence of 95
f2d = bf.first_digits(sp.l_r, digs=2, decimals=8, confidence=95)
Explanation: Assessing conformity
There are some tests to more precisely evaluate if the data studied is a good fit to Benford's Law.
The first we'll use is the Z statistic for the proportions.
In the digits functions, you can turn it on by settign the parameter confidence, which will tell the function which confidence level to consider after calculating the Z score for each proportion.
End of explanation
# First Three Digits Test, now with 99% confidence level
# digs=3 for the first three digits
f3d = bf.first_digits(sp.l_r, digs=3, decimals=8, confidence=99)
# The First Three Digits plot is better seen and zoomed in and out without the inline plotting.
# Try %matplotlib
Explanation: Some things happened:
<li>It printed a DataFrame wiith the significant positive deviations, in descending order of the Z score.</li>
<li>In the plot, to the Benford Expected line, it added upper and lower boundaries, based on the level of confidence by the parameter. Accordingly, it changed the colors of the bars whose proportions fell lower or higher than the drawn boundaries, for better vizualisation.</li>
The confidence parameter takes the follwoing values other than None: 80, 85, 90, 95, 99 99.9, 99.99, 99.999, 99.9999 and 99.99999.
Other tests
We can do all this with the First Three Digits, Second Digit and the Last Two Digits tests too.
End of explanation
# Second Digit Test
sd = bf.second_digit(sp.l_r, decimals=8, confidence=95)
# Last Two Digits Test
l2d = bf.last_two_digits(sp.l_r, decimals=8, confidence=90)
Explanation: There are also the Second Digit test, and Last Two Digits test, as shown bellow.
End of explanation
mad1 = bf.mad(sp.l_r, test=1, decimals=8) # test=1 : MAD for the First Digits
mad1
Explanation: Other Important Parameters
<li>digs: only used in the First Digits function, to tell it which test to run: 1- First Digits; 2- Fist Two Digits; and 3- First Three Digits.</li>
<li>decimals: informs the number of decimal places to consider. Defaluts to 2, for currencies, but I set it to 8 here, since we are dealing with log returns (long floats). If the sequence is of integers, set it to 0. You may also set it to infer if you don't know exactly or if the data has registries with different number of decimal places, and it will treat every registry separately.</li>
<li>sign: tells which portion of the data to consider. pos: only the positive entries; neg: only the negative ones; all: all entries but zeros. Defaults to all.</li>
<li>inform: gives information about the test during its run, like the number of registries analysed, the number of registries discarded according to each test (ie, < 10 for the First Digits), and shows the top Z scores of the resulting DataFrame if confidence is not None.</li>
<li>high_Z: chooses which Z scores to be used when displaying results, according to the confidence level chosen. Defaluts to pos, which will return only values higher than the expexted frequencies; neg will return only values lower than the expexted frequencies; all will return both extremes (positive and negative); and an integer will return the first n entries, positive and negative, regardless of whether Z is higher than the confidence or not.</li>
<li>limit_N: sets a limit to the sample size for the calculation of the Z scores. This may be found useful if the sample is too big, due to the Z test power problem. Defaults to None.</li>
<li>show_plot: draws the test plot. Defaults to True. Note that if confidence is not None, the plot will highlight the bars outside the lower and upper boundaries, regardless of the high_Z value.</li>
<li>MAD and MSE: calculate, respectively, the Mean Absolute Deviation and the Mean Squared Error of the sample, for each test. Defaults to False. Both can be used inside the tests' functions or separetely, in their own functions, mad and mse.</li>
MAD
The Mean Absolute Deviation, or MAD, is, as the name states, the average of all absolute deviations between the found proportions and the Benford's expected ones.
<a href=www.sciencedirect.com/science/article/pii/S0748575100000087>Drake and Nigrini (2000)</a> developed this model, later revised by <a href=www.wiley.com/WileyCDA/WileyTitle/productCd-0470890460.html>Nigrini (2001)</a>, using empirical data to set limits of conformity for the First, First Two, First Three and Second Digits tests.
The MAD averages the proportions, so it is not directly influenced by the sample size. The lower the MAD, the better the confotmity.
End of explanation
mad2 = bf.mad(sp.l_r, test=2, decimals=8) # test=2 : MAD for the First Two Digits
mad2
mad3 = bf.mad(sp.l_r, test=3, decimals=8) # test=3 : MAD for the First Three Digits
mad3
mad_sd = bf.mad(sp.l_r, test=22, decimals=8) # test=22 : MAD for the Second Digits
mad_sd
mad_l2d = bf.mad(sp.l_r, test=-2, decimals=8) # test=-2 : MAD for the Last Two Digits
mad_l2d
Explanation: Note that you must choose the test parameter, since there is one MAD for each test.
<li>First Digit: 1 or 'F1D';</li>
<li>First Two Digits: 2 or 'F2D';</li>
<li>First Three Digits: 3 or 'F3D';</li>
<li>Second Digit: 22 or 'SD';</li>
<li>Last Two Digits: -2 or 'L2D'; # pithonic</li>
End of explanation
f2d = bf.first_digits(sp.l_r, digs=2, decimals=8, MAD=True, show_plot=False)
sd = bf.second_digit(sp.l_r, decimals=8, MAD=True, show_plot=False)
Explanation: Or you can set the MAD parameter to True when running the tests functions, and it will also give the corresponding conformity limits (as long as inform is also True).
End of explanation
mant = bf.mantissas(sp.l_r, inform=True, show_plot=True)
mant.hist(bins=30, figsize=(12,5))
Explanation: Mantissas
The mantissa is the decimal part of a logarithm. In a Benford data set, the mantissas of the registries' logs are uniformly distributed, such that when ordered,they should form a straight line in the interval [0,1), with slope 1/N, N being the sample size..
End of explanation |
3,470 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Airflow Composer Example
Demonstration that uses Airflow/Composer native, Airflow/Composer local, and StarThinker tasks in the same generated DAG.
License
Copyright 2020 Google LLC,
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https
Step1: 2. Set Configuration
This code is required to initialize the project. Fill in required fields and press play.
If the recipe uses a Google Cloud Project
Step2: 3. Enter Airflow Composer Example Recipe Parameters
Execute this using Airflow or Composer, the Colab and UI recipe is for refence only.
This is an example DAG that will execute and print dates and text.
Run it once to ensure everything works, then customize it.
Modify the values below for your use case, can be done multiple times, then click play.
Step3: 4. Execute Airflow Composer Example
This does NOT need to be modified unless you are changing the recipe, click play. | Python Code:
!pip install git+https://github.com/google/starthinker
Explanation: Airflow Composer Example
Demonstration that uses Airflow/Composer native, Airflow/Composer local, and StarThinker tasks in the same generated DAG.
License
Copyright 2020 Google LLC,
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Disclaimer
This is not an officially supported Google product. It is a reference implementation. There is absolutely NO WARRANTY provided for using this code. The code is Apache Licensed and CAN BE fully modified, white labeled, and disassembled by your team.
This code generated (see starthinker/scripts for possible source):
- Command: "python starthinker_ui/manage.py colab"
- Command: "python starthinker/tools/colab.py [JSON RECIPE]"
1. Install Dependencies
First install the libraries needed to execute recipes, this only needs to be done once, then click play.
End of explanation
from starthinker.util.configuration import Configuration
CONFIG = Configuration(
project="",
client={},
service={},
user="/content/user.json",
verbose=True
)
Explanation: 2. Set Configuration
This code is required to initialize the project. Fill in required fields and press play.
If the recipe uses a Google Cloud Project:
Set the configuration project value to the project identifier from these instructions.
If the recipe has auth set to user:
If you have user credentials:
Set the configuration user value to your user credentials JSON.
If you DO NOT have user credentials:
Set the configuration client value to downloaded client credentials.
If the recipe has auth set to service:
Set the configuration service value to downloaded service credentials.
End of explanation
FIELDS = {
'auth_read':'user', # Credentials used for reading data.
}
print("Parameters Set To: %s" % FIELDS)
Explanation: 3. Enter Airflow Composer Example Recipe Parameters
Execute this using Airflow or Composer, the Colab and UI recipe is for refence only.
This is an example DAG that will execute and print dates and text.
Run it once to ensure everything works, then customize it.
Modify the values below for your use case, can be done multiple times, then click play.
End of explanation
from starthinker.util.configuration import execute
from starthinker.util.recipe import json_set_fields
TASKS = [
{
'airflow':{
'__comment__':'Calls a native Airflow operator.',
'operators':{
'bash_operator':{
'BashOperator':{
'bash_command':'date'
}
}
}
}
},
{
'starthinker.airflow':{
'__comment__':'Calls an custom operator, requires import of library.',
'operators':{
'hello':{
'Hello':{
'say':'Hi, there!'
}
}
}
}
},
{
'hello':{
'__comment__':'Calls a StarThinker task.',
'auth':'user',
'say':'Hello World'
}
}
]
json_set_fields(TASKS, FIELDS)
execute(CONFIG, TASKS, force=True)
Explanation: 4. Execute Airflow Composer Example
This does NOT need to be modified unless you are changing the recipe, click play.
End of explanation |
3,471 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Copyright 2020 The TensorFlow IO Authors.
Step1: Robust machine learning on streaming data using Kafka and Tensorflow-IO
<table class="tfo-notebook-buttons" align="left">
<td>
<a target="_blank" href="https
Step2: Import packages
Step3: Validate tf and tfio imports
Step4: Download and setup Kafka and Zookeeper instances
For demo purposes, the following instances are setup locally
Step5: Using the default configurations (provided by Apache Kafka) for spinning up the instances.
Step6: Once the instances are started as daemon processes, grep for kafka in the processes list. The two java processes correspond to zookeeper and the kafka instances.
Step7: Create the kafka topics with the following specs
Step8: Describe the topic for details on the configuration
Step9: The replication factor 1 indicates that the data is not being replicated. This is due to the presence of a single broker in our kafka setup.
In production systems, the number of bootstrap servers can be in the range of 100's of nodes. That is where the fault-tolerance using replication comes into picture.
Please refer to the docs for more details.
SUSY Dataset
Kafka being an event streaming platform, enables data from various sources to be written into it. For instance
Step10: Explore the dataset
The first column is the class label (1 for signal, 0 for background), followed by the 18 features (8 low-level features then 10 high-level features).
The first 8 features are kinematic properties measured by the particle detectors in the accelerator. The last 10 features are functions of the first 8 features. These are high-level features derived by physicists to help discriminate between the two classes.
Step11: The entire dataset consists of 5 million rows. However, for the purpose of this tutorial, let's consider only a fraction of the dataset (100,000 rows) so that less time is spent on the moving the data and more time on understanding the functionality of the api.
Step12: Split the dataset
Step13: Store the train and test data in kafka
Storing the data in kafka simulates an environment for continuous remote data retrieval for training and inference purposes.
Step14: Define the tfio train dataset
The IODataset class is utilized for streaming data from kafka into tensorflow. The class inherits from tf.data.Dataset and thus has all the useful functionalities of tf.data.Dataset out of the box.
Step15: Build and train the model
Step16: Note
Step17: Though this class can be used for training purposes, there are caveats which need to be addressed. Once all the messages are read from kafka and the latest offsets are committed using the streaming.KafkaGroupIODataset, the consumer doesn't restart reading the messages from the beginning. Thus, while training, it is possible only to train for a single epoch with the data continuously flowing in. This kind of a functionality has limited use cases during the training phase wherein, once a datapoint has been consumed by the model it is no longer required and can be discarded.
However, this functionality shines when it comes to robust inference with exactly-once semantics.
evaluate the performance on the test data
Step18: Since the inference is based on 'exactly-once' semantics, the evaluation on the test set can be run only once. In order to run the inference again on the test data, a new consumer group should be used.
Track the offset lag of the testcg consumer group
Step19: Once the current-offset matches the log-end-offset for all the partitions, it indicates that the consumer(s) have completed fetching all the messages from the kafka topic.
Online learning
The online machine learning paradigm is a bit different from the traditional/conventional way of training machine learning models. In the former case, the model continues to incrementally learn/update it's parameters as soon as the new data points are available and this process is expected to continue indefinitely. This is unlike the latter approaches where the dataset is fixed and the model iterates over it n number of times. In online learning, the data once consumed by the model may not be available for training again.
By utilizing the streaming.KafkaBatchIODataset, it is now possible to train the models in this fashion. Let's continue to use our SUSY dataset for demonstrating this functionality.
The tfio training dataset for online learning
The streaming.KafkaBatchIODataset is similar to the streaming.KafkaGroupIODataset in it's API. Additionally, it is recommended to utilize the stream_timeout parameter to configure the duration for which the dataset will block for new messages before timing out. In the instance below, the dataset is configured with a stream_timeout of 10000 milliseconds. This implies that, after all the messages from the topic have been consumed, the dataset will wait for an additional 10 seconds before timing out and disconnecting from the kafka cluster. If new messages are streamed into the topic before timing out, the data consumption and model training resumes for those newly consumed data points. To block indefinitely, set it to -1.
Step20: Every item that the online_train_ds generates is a tf.data.Dataset in itself. Thus, all the standard transformations can be applied as usual. | Python Code:
#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
Explanation: Copyright 2020 The TensorFlow IO Authors.
End of explanation
!pip install tensorflow-io
!pip install kafka-python
Explanation: Robust machine learning on streaming data using Kafka and Tensorflow-IO
<table class="tfo-notebook-buttons" align="left">
<td>
<a target="_blank" href="https://www.tensorflow.org/io/tutorials/kafka"><img src="https://www.tensorflow.org/images/tf_logo_32px.png" />View on TensorFlow.org</a>
</td>
<td>
<a target="_blank" href="https://colab.research.google.com/github/tensorflow/io/blob/master/docs/tutorials/kafka.ipynb"><img src="https://www.tensorflow.org/images/colab_logo_32px.png" />Run in Google Colab</a>
</td>
<td>
<a target="_blank" href="https://github.com/tensorflow/io/blob/master/docs/tutorials/kafka.ipynb"><img src="https://www.tensorflow.org/images/GitHub-Mark-32px.png" />View source on GitHub</a>
</td>
<td>
<a href="https://storage.googleapis.com/tensorflow_docs/io/docs/tutorials/kafka.ipynb"><img src="https://www.tensorflow.org/images/download_logo_32px.png" />Download notebook</a>
</td>
</table>
Overview
This tutorial focuses on streaming data from a Kafka cluster into a tf.data.Dataset which is then used in conjunction with tf.keras for training and inference.
Kafka is primarily a distributed event-streaming platform which provides scalable and fault-tolerant streaming data across data pipelines. It is an essential technical component of a plethora of major enterprises where mission-critical data delivery is a primary requirement.
NOTE: A basic understanding of the kafka components will help you in following the tutorial with ease.
NOTE: A Java runtime environment is required to run this tutorial.
Setup
Install the required tensorflow-io and kafka packages
End of explanation
import os
from datetime import datetime
import time
import threading
import json
from kafka import KafkaProducer
from kafka.errors import KafkaError
from sklearn.model_selection import train_test_split
import pandas as pd
import tensorflow as tf
import tensorflow_io as tfio
Explanation: Import packages
End of explanation
print("tensorflow-io version: {}".format(tfio.__version__))
print("tensorflow version: {}".format(tf.__version__))
Explanation: Validate tf and tfio imports
End of explanation
!curl -sSOL https://dlcdn.apache.org/kafka/3.1.0/kafka_2.13-3.1.0.tgz
!tar -xzf kafka_2.13-3.1.0.tgz
Explanation: Download and setup Kafka and Zookeeper instances
For demo purposes, the following instances are setup locally:
Kafka (Brokers: 127.0.0.1:9092)
Zookeeper (Node: 127.0.0.1:2181)
End of explanation
!./kafka_2.13-3.1.0/bin/zookeeper-server-start.sh -daemon ./kafka_2.13-3.1.0/config/zookeeper.properties
!./kafka_2.13-3.1.0/bin/kafka-server-start.sh -daemon ./kafka_2.13-3.1.0/config/server.properties
!echo "Waiting for 10 secs until kafka and zookeeper services are up and running"
!sleep 10
Explanation: Using the default configurations (provided by Apache Kafka) for spinning up the instances.
End of explanation
!ps -ef | grep kafka
Explanation: Once the instances are started as daemon processes, grep for kafka in the processes list. The two java processes correspond to zookeeper and the kafka instances.
End of explanation
!./kafka_2.13-3.1.0/bin/kafka-topics.sh --create --bootstrap-server 127.0.0.1:9092 --replication-factor 1 --partitions 1 --topic susy-train
!./kafka_2.13-3.1.0/bin/kafka-topics.sh --create --bootstrap-server 127.0.0.1:9092 --replication-factor 1 --partitions 2 --topic susy-test
Explanation: Create the kafka topics with the following specs:
susy-train: partitions=1, replication-factor=1
susy-test: partitions=2, replication-factor=1
End of explanation
!./kafka_2.13-3.1.0/bin/kafka-topics.sh --describe --bootstrap-server 127.0.0.1:9092 --topic susy-train
!./kafka_2.13-3.1.0/bin/kafka-topics.sh --describe --bootstrap-server 127.0.0.1:9092 --topic susy-test
Explanation: Describe the topic for details on the configuration
End of explanation
!curl -sSOL https://archive.ics.uci.edu/ml/machine-learning-databases/00279/SUSY.csv.gz
Explanation: The replication factor 1 indicates that the data is not being replicated. This is due to the presence of a single broker in our kafka setup.
In production systems, the number of bootstrap servers can be in the range of 100's of nodes. That is where the fault-tolerance using replication comes into picture.
Please refer to the docs for more details.
SUSY Dataset
Kafka being an event streaming platform, enables data from various sources to be written into it. For instance:
Web traffic logs
Astronomical measurements
IoT sensor data
Product reviews and many more.
For the purpose of this tutorial, lets download the SUSY dataset and feed the data into kafka manually. The goal of this classification problem is to distinguish between a signal process which produces supersymmetric particles and a background process which does not.
End of explanation
COLUMNS = [
# labels
'class',
# low-level features
'lepton_1_pT',
'lepton_1_eta',
'lepton_1_phi',
'lepton_2_pT',
'lepton_2_eta',
'lepton_2_phi',
'missing_energy_magnitude',
'missing_energy_phi',
# high-level derived features
'MET_rel',
'axial_MET',
'M_R',
'M_TR_2',
'R',
'MT2',
'S_R',
'M_Delta_R',
'dPhi_r_b',
'cos(theta_r1)'
]
Explanation: Explore the dataset
The first column is the class label (1 for signal, 0 for background), followed by the 18 features (8 low-level features then 10 high-level features).
The first 8 features are kinematic properties measured by the particle detectors in the accelerator. The last 10 features are functions of the first 8 features. These are high-level features derived by physicists to help discriminate between the two classes.
End of explanation
susy_iterator = pd.read_csv('SUSY.csv.gz', header=None, names=COLUMNS, chunksize=100000)
susy_df = next(susy_iterator)
susy_df.head()
# Number of datapoints and columns
len(susy_df), len(susy_df.columns)
# Number of datapoints belonging to each class (0: background noise, 1: signal)
len(susy_df[susy_df["class"]==0]), len(susy_df[susy_df["class"]==1])
Explanation: The entire dataset consists of 5 million rows. However, for the purpose of this tutorial, let's consider only a fraction of the dataset (100,000 rows) so that less time is spent on the moving the data and more time on understanding the functionality of the api.
End of explanation
train_df, test_df = train_test_split(susy_df, test_size=0.4, shuffle=True)
print("Number of training samples: ",len(train_df))
print("Number of testing sample: ",len(test_df))
x_train_df = train_df.drop(["class"], axis=1)
y_train_df = train_df["class"]
x_test_df = test_df.drop(["class"], axis=1)
y_test_df = test_df["class"]
# The labels are set as the kafka message keys so as to store data
# in multiple-partitions. Thus, enabling efficient data retrieval
# using the consumer groups.
x_train = list(filter(None, x_train_df.to_csv(index=False).split("\n")[1:]))
y_train = list(filter(None, y_train_df.to_csv(index=False).split("\n")[1:]))
x_test = list(filter(None, x_test_df.to_csv(index=False).split("\n")[1:]))
y_test = list(filter(None, y_test_df.to_csv(index=False).split("\n")[1:]))
NUM_COLUMNS = len(x_train_df.columns)
len(x_train), len(y_train), len(x_test), len(y_test)
Explanation: Split the dataset
End of explanation
def error_callback(exc):
raise Exception('Error while sendig data to kafka: {0}'.format(str(exc)))
def write_to_kafka(topic_name, items):
count=0
producer = KafkaProducer(bootstrap_servers=['127.0.0.1:9092'])
for message, key in items:
producer.send(topic_name, key=key.encode('utf-8'), value=message.encode('utf-8')).add_errback(error_callback)
count+=1
producer.flush()
print("Wrote {0} messages into topic: {1}".format(count, topic_name))
write_to_kafka("susy-train", zip(x_train, y_train))
write_to_kafka("susy-test", zip(x_test, y_test))
Explanation: Store the train and test data in kafka
Storing the data in kafka simulates an environment for continuous remote data retrieval for training and inference purposes.
End of explanation
def decode_kafka_item(item):
message = tf.io.decode_csv(item.message, [[0.0] for i in range(NUM_COLUMNS)])
key = tf.strings.to_number(item.key)
return (message, key)
BATCH_SIZE=64
SHUFFLE_BUFFER_SIZE=64
train_ds = tfio.IODataset.from_kafka('susy-train', partition=0, offset=0)
train_ds = train_ds.shuffle(buffer_size=SHUFFLE_BUFFER_SIZE)
train_ds = train_ds.map(decode_kafka_item)
train_ds = train_ds.batch(BATCH_SIZE)
Explanation: Define the tfio train dataset
The IODataset class is utilized for streaming data from kafka into tensorflow. The class inherits from tf.data.Dataset and thus has all the useful functionalities of tf.data.Dataset out of the box.
End of explanation
# Set the parameters
OPTIMIZER="adam"
LOSS=tf.keras.losses.BinaryCrossentropy(from_logits=True)
METRICS=['accuracy']
EPOCHS=10
# design/build the model
model = tf.keras.Sequential([
tf.keras.layers.Input(shape=(NUM_COLUMNS,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dropout(0.4),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.4),
tf.keras.layers.Dense(1, activation='sigmoid')
])
print(model.summary())
# compile the model
model.compile(optimizer=OPTIMIZER, loss=LOSS, metrics=METRICS)
# fit the model
model.fit(train_ds, epochs=EPOCHS)
Explanation: Build and train the model
End of explanation
test_ds = tfio.experimental.streaming.KafkaGroupIODataset(
topics=["susy-test"],
group_id="testcg",
servers="127.0.0.1:9092",
stream_timeout=10000,
configuration=[
"session.timeout.ms=7000",
"max.poll.interval.ms=8000",
"auto.offset.reset=earliest"
],
)
def decode_kafka_test_item(raw_message, raw_key):
message = tf.io.decode_csv(raw_message, [[0.0] for i in range(NUM_COLUMNS)])
key = tf.strings.to_number(raw_key)
return (message, key)
test_ds = test_ds.map(decode_kafka_test_item)
test_ds = test_ds.batch(BATCH_SIZE)
Explanation: Note: Please do not confuse the training step with online training. It's an entirely different paradigm which will be covered in a later section.
Since only a fraction of the dataset is being utilized, our accuracy is limited to ~78% during the training phase. However, please feel free to store additional data in kafka for a better model performance. Also, since the goal was to just demonstrate the functionality of the tfio kafka datasets, a smaller and less-complicated neural network was used. However, one can increase the complexity of the model, modify the learning strategy, tune hyper-parameters etc for exploration purposes. For a baseline approach, please refer to this article.
Infer on the test data
To infer on the test data by adhering to the 'exactly-once' semantics along with fault-tolerance, the streaming.KafkaGroupIODataset can be utilized.
Define the tfio test dataset
The stream_timeout parameter blocks for the given duration for new data points to be streamed into the topic. This removes the need for creating new datasets if the data is being streamed into the topic in an intermittent fashion.
End of explanation
res = model.evaluate(test_ds)
print("test loss, test acc:", res)
Explanation: Though this class can be used for training purposes, there are caveats which need to be addressed. Once all the messages are read from kafka and the latest offsets are committed using the streaming.KafkaGroupIODataset, the consumer doesn't restart reading the messages from the beginning. Thus, while training, it is possible only to train for a single epoch with the data continuously flowing in. This kind of a functionality has limited use cases during the training phase wherein, once a datapoint has been consumed by the model it is no longer required and can be discarded.
However, this functionality shines when it comes to robust inference with exactly-once semantics.
evaluate the performance on the test data
End of explanation
!./kafka_2.13-3.1.0/bin/kafka-consumer-groups.sh --bootstrap-server 127.0.0.1:9092 --describe --group testcg
Explanation: Since the inference is based on 'exactly-once' semantics, the evaluation on the test set can be run only once. In order to run the inference again on the test data, a new consumer group should be used.
Track the offset lag of the testcg consumer group
End of explanation
online_train_ds = tfio.experimental.streaming.KafkaBatchIODataset(
topics=["susy-train"],
group_id="cgonline",
servers="127.0.0.1:9092",
stream_timeout=10000, # in milliseconds, to block indefinitely, set it to -1.
configuration=[
"session.timeout.ms=7000",
"max.poll.interval.ms=8000",
"auto.offset.reset=earliest"
],
)
Explanation: Once the current-offset matches the log-end-offset for all the partitions, it indicates that the consumer(s) have completed fetching all the messages from the kafka topic.
Online learning
The online machine learning paradigm is a bit different from the traditional/conventional way of training machine learning models. In the former case, the model continues to incrementally learn/update it's parameters as soon as the new data points are available and this process is expected to continue indefinitely. This is unlike the latter approaches where the dataset is fixed and the model iterates over it n number of times. In online learning, the data once consumed by the model may not be available for training again.
By utilizing the streaming.KafkaBatchIODataset, it is now possible to train the models in this fashion. Let's continue to use our SUSY dataset for demonstrating this functionality.
The tfio training dataset for online learning
The streaming.KafkaBatchIODataset is similar to the streaming.KafkaGroupIODataset in it's API. Additionally, it is recommended to utilize the stream_timeout parameter to configure the duration for which the dataset will block for new messages before timing out. In the instance below, the dataset is configured with a stream_timeout of 10000 milliseconds. This implies that, after all the messages from the topic have been consumed, the dataset will wait for an additional 10 seconds before timing out and disconnecting from the kafka cluster. If new messages are streamed into the topic before timing out, the data consumption and model training resumes for those newly consumed data points. To block indefinitely, set it to -1.
End of explanation
def decode_kafka_online_item(raw_message, raw_key):
message = tf.io.decode_csv(raw_message, [[0.0] for i in range(NUM_COLUMNS)])
key = tf.strings.to_number(raw_key)
return (message, key)
for mini_ds in online_train_ds:
mini_ds = mini_ds.shuffle(buffer_size=32)
mini_ds = mini_ds.map(decode_kafka_online_item)
mini_ds = mini_ds.batch(32)
if len(mini_ds) > 0:
model.fit(mini_ds, epochs=3)
Explanation: Every item that the online_train_ds generates is a tf.data.Dataset in itself. Thus, all the standard transformations can be applied as usual.
End of explanation |
3,472 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Wuauclt CreateRemoteThread Execution
Metadata
| | |
|
Step1: Download & Process Mordor Dataset
Step2: Analytic I
Look for wuauclt with the specific parameters used to load and execute a DLL.
| Data source | Event Provider | Relationship | Event |
|
Step3: Analytic II
Look for unsigned DLLs being loaded by wuauclt. You might have to stack the results and find potential anomalies over time.
| Data source | Event Provider | Relationship | Event |
|
Step4: Analytic III
Look for wuauclt creating and running a thread in the virtual address space of another process via the CreateRemoteThread API.
| Data source | Event Provider | Relationship | Event |
|
Step5: Analytic IV
Look for recent files created being loaded by wuauclt.
| Data source | Event Provider | Relationship | Event |
|
Step6: Analytic V
Look for wuauclt loading recently created DLLs and writing to another process
| Data source | Event Provider | Relationship | Event |
| | Python Code:
from openhunt.mordorutils import *
spark = get_spark()
Explanation: Wuauclt CreateRemoteThread Execution
Metadata
| | |
|:------------------|:---|
| collaborators | ['@Cyb3rWard0g'] |
| creation date | 2020/10/12 |
| modification date | 2020/10/12 |
| playbook related | [] |
Hypothesis
Adversaries might be proxy executing code via the Windows Update client utility in my environment and creating and running a thread in the virtual address space of another process via the CreateRemoteThread API to bypass rules looking for it calling out to the Internet.
Technical Context
The Windows Update client (wuauclt.exe) utility allows you some control over the functioning of the Windows Update Agent.
Offensive Tradecraft
Adversaries can leverage this utility to proxy the execution of code by specifying an arbitrary DLL with the following command line wuauclt.exe /UpdateDeploymentProvider <Full_Path_To_DLL> /RunHandlerComServer
Mordor Test Data
| | |
|:----------|:----------|
| metadata | https://mordordatasets.com/notebooks/small/windows/05_defense_evasion/SDWIN-201012183248.html |
| link | https://raw.githubusercontent.com/OTRF/mordor/master/datasets/small/windows/defense_evasion/host/covenant_lolbin_wuauclt_createremotethread.zip |
Analytics
Initialize Analytics Engine
End of explanation
mordor_file = "https://raw.githubusercontent.com/OTRF/mordor/master/datasets/small/windows/defense_evasion/host/covenant_lolbin_wuauclt_createremotethread.zip"
registerMordorSQLTable(spark, mordor_file, "mordorTable")
Explanation: Download & Process Mordor Dataset
End of explanation
df = spark.sql(
'''
SELECT `@timestamp`, Hostname, Image, CommandLine
FROM mordorTable
WHERE Channel = 'Microsoft-Windows-Sysmon/Operational'
AND EventID = 1
AND Image LIKE '%wuauclt.exe'
AND CommandLine LIKE '%wuauclt%UpdateDeploymentProvider%.dll%RunHandlerComServer'
'''
)
df.show(10,False)
Explanation: Analytic I
Look for wuauclt with the specific parameters used to load and execute a DLL.
| Data source | Event Provider | Relationship | Event |
|:------------|:---------------|--------------|-------|
| Process | Microsoft-Windows-Sysmon/Operational | Process created Process | 1 |
End of explanation
df = spark.sql(
'''
SELECT `@timestamp`, Hostname, Image, ImageLoaded
FROM mordorTable
WHERE Channel = 'Microsoft-Windows-Sysmon/Operational'
AND EventID = 7
AND Image LIKE '%wuauclt.exe'
AND Signed = 'false'
'''
)
df.show(10,False)
Explanation: Analytic II
Look for unsigned DLLs being loaded by wuauclt. You might have to stack the results and find potential anomalies over time.
| Data source | Event Provider | Relationship | Event |
|:------------|:---------------|--------------|-------|
| Module | Microsoft-Windows-Sysmon/Operational | Process loaded DLL | 7 |
End of explanation
df = spark.sql(
'''
SELECT `@timestamp`, Hostname, TargetImage
FROM mordorTable
WHERE Channel = 'Microsoft-Windows-Sysmon/Operational'
AND EventID = 8
AND SourceImage LIKE '%wuauclt.exe'
'''
)
df.show(10,False)
Explanation: Analytic III
Look for wuauclt creating and running a thread in the virtual address space of another process via the CreateRemoteThread API.
| Data source | Event Provider | Relationship | Event |
|:------------|:---------------|--------------|-------|
| Process | Microsoft-Windows-Sysmon/Operational | Process wrote_to Process | 8 |
End of explanation
df = spark.sql(
'''
SELECT `@timestamp`, Hostname, ImageLoaded
FROM mordorTable b
INNER JOIN (
SELECT TargetFilename, ProcessGuid
FROM mordorTable
WHERE Channel = 'Microsoft-Windows-Sysmon/Operational'
AND EventID = 11
) a
ON b.ImageLoaded = a.TargetFilename
WHERE Channel = 'Microsoft-Windows-Sysmon/Operational'
AND EventID = 7
AND Image LIKE '%wuauclt.exe'
'''
)
df.show(10,False)
Explanation: Analytic IV
Look for recent files created being loaded by wuauclt.
| Data source | Event Provider | Relationship | Event |
|:------------|:---------------|--------------|-------|
| File | Microsoft-Windows-Sysmon/Operational | Process created File | 11 |
| File | Microsoft-Windows-Sysmon/Operational | Process loaded DLL | 7 |
End of explanation
df = spark.sql(
'''
SELECT `@timestamp`, Hostname, d.TargetImage, c.ImageLoaded
FROM mordorTable d
INNER JOIN (
SELECT b.ProcessGuid, b.ImageLoaded
FROM mordorTable b
INNER JOIN (
SELECT TargetFilename, ProcessGuid
FROM mordorTable
WHERE Channel = 'Microsoft-Windows-Sysmon/Operational'
AND EventID = 11
) a
ON b.ImageLoaded = a.TargetFilename
WHERE Channel = 'Microsoft-Windows-Sysmon/Operational'
AND EventID = 7
AND Image LIKE '%wuauclt.exe'
) c
ON d.SourceProcessGuid = c.ProcessGuid
WHERE Channel = 'Microsoft-Windows-Sysmon/Operational'
AND EventID = 8
AND SourceImage LIKE '%wuauclt.exe'
'''
)
df.show(10,False)
Explanation: Analytic V
Look for wuauclt loading recently created DLLs and writing to another process
| Data source | Event Provider | Relationship | Event |
|:------------|:---------------|--------------|-------|
| Module | Microsoft-Windows-Sysmon/Operational | Process created File | 11 |
| Module | Microsoft-Windows-Sysmon/Operational | Process loaded DLL | 7 |
| Module | Microsoft-Windows-Sysmon/Operational | Process wrote_to Process | 8 |
End of explanation |
3,473 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<div align="right">Python 3.6 [conda env
Step1: For this example, timeit() needs to be the only function in the cell, and then your code is called in as a valid function call as in this demo
Step2: Should this malfunction and/or throw errors, try restarting the kernel and re-running all pre-requisite cells and then this syntax should work.
Step3: If you get the 'slowest run took ...' message, try re-running the code cell to over-write the caching
Step4: Unlike timeit(), the other options provided here (using iPython cell magics) can test any snippet of code within a python cell.
Symmetric Difference Example
This code from hackerrank shows increasingly smaller snippets of code to find the symmentric difference between two sets. Symmetric difference of sets A and B is the set of values from both sets that do not intersect (i.e., values in A not found in B plus the values in B not found in A). This code was written to accept 4 lines of input as per a www.hackerrank.com specification. The problem itself is also from www.hackerrank.com.
Performance tests are attempted but are hard to know what is really going on since variance in the time to input the values could also account for speed differences just as easily as the possibility of coding efficiencies.
Step5: These tests use the following inputs. As per requirements in the challenge problem, what each line mean is also given here | Python Code:
def myFun(x):
return (x**x)**x
myFun(9)
Explanation: <div align="right">Python 3.6 [conda env: PY36]</div>
Performance Testing in iPython/Jupyter NBs
The timeit() command appears to have strict limitations in how you can use it within a Jupyter Notebook. For it to work most effectively:
- organize the code to test in a function that returns a value
- ensure it is not printing to screen or the code will print 1000 times (or however many times timeit() is configured to iterate)
- make sure that timeit() is the only line in the test cell as shown in these examples
- for more advanced use of timeit() and open more options for how to use it and related functions, check the documentation. This library was creatd in Python 2 and is compatible (and may have updated in Python 3.
To get around this limitation, examples are also provided using %timeit() and %time()
To understand the abbreviations in timeit, %timeit, and %time performance metrics, see this wikipedia post.
For additional research on performance testing and code time metrics: timing and profiling
Simple Example: timeit(), %time, %timeit, %%timeit.
The function here is something stupid and simple just to show how to use these capabilities ...
End of explanation
timeit(myFun(12))
Explanation: For this example, timeit() needs to be the only function in the cell, and then your code is called in as a valid function call as in this demo:
End of explanation
%timeit 10*1000000
# this syntax allows comments ... note that if you leave off the numeric argument, %timeit seems to do nothing
myFun(12)
Explanation: Should this malfunction and/or throw errors, try restarting the kernel and re-running all pre-requisite cells and then this syntax should work.
End of explanation
%timeit 10*1000000
# this syntax allows comments ... note that if you leave off the numeric argument, %timeit seems to do nothing
myFun(12)
%%timeit
# this syntax allows comments ... if defaults the looping argument
myFun(12)
%time
# generates "wall time" instead of CPU time
myFun(12)
# getting more detail using %time on a script or code
%time {for i in range(10*1000000): x=1}
%timeit -n 1 10*1000000
# does it just once which may be inaccurate due to random events
myFun(12)
Explanation: If you get the 'slowest run took ...' message, try re-running the code cell to over-write the caching
End of explanation
def find_symmetricDiff_inputSetsAB_v1():
len_setA = int(input())
set_A = set([int(i) for i in input().split()])
len_setB = int(input())
set_B = set([int(i) for i in input().split()])
[print(val) for val in sorted(list(set_A.difference(set_B).union(set_B.difference(set_A))))]
def find_symmetricDiff_inputSetsAB_v2():
setsLst = [0,0]
for i in range(2):
int(input()) # eat value ... don't need it
setsLst[i] = set([int(i) for i in input().split()])
[print(val) for val in sorted(list(setsLst[0].difference(setsLst[1]).union(setsLst[1].difference(setsLst[0]))))]
''' understanding next two versions:
* key=int, applies int() to each value to be sorted so the values are sorted as 1,2,3 ... not: '1', '2', '3'
* a^b is the same as a.symmetric_difference(b)
these two come from discussion boards on hackerrank
'''
def find_symmetricDiff_inputSetsAB_v3():
a,b = [set(input().split()) for _ in range(4)][1::2]
return '\n'.join(sorted(a.symmetric_difference(b), key=int))
def find_symmetricDiff_inputSetsAB_v4():
a,b = [set(input().split()) for _ in range(4)][1::2]
return '\n'.join(sorted(a^b, key=int))
Explanation: Unlike timeit(), the other options provided here (using iPython cell magics) can test any snippet of code within a python cell.
Symmetric Difference Example
This code from hackerrank shows increasingly smaller snippets of code to find the symmentric difference between two sets. Symmetric difference of sets A and B is the set of values from both sets that do not intersect (i.e., values in A not found in B plus the values in B not found in A). This code was written to accept 4 lines of input as per a www.hackerrank.com specification. The problem itself is also from www.hackerrank.com.
Performance tests are attempted but are hard to know what is really going on since variance in the time to input the values could also account for speed differences just as easily as the possibility of coding efficiencies.
End of explanation
i1 = int(1000000000000000000008889934567)
i2 = int(73277773377737373000000000000007777888)
print(i1)
print(i2)
%timeit -n 1 10*1000000
find_symmetricDiff_inputSetsAB_v1()
# timeit(find_symmetricDiff_inputSetsAB_v1(), 1)
Explanation: These tests use the following inputs. As per requirements in the challenge problem, what each line mean is also given here:
<pre>
10
999 10001 574 39 12345678900100111, 787878, 999999, 1000000000000000000008889934567, 8989, 1111111111111111111111110000009999999
5
999 10001 574 39 73277773377737373000000000000007777888
</pre>
End of explanation |
3,474 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Advanced Usage of Domain
Domain and auxiliary classes (KV, Option, ConfigAlias) are used to define combinations of parameters to try in Research.
We start with some useful imports and constant definitions
Step1: Basic usage
Option is a class for parameter name and values that will be used in a Research. Values of the Option can be defined as array or Sampler. Can be easily transformed to Domain to construct iterator which will produce configs.
Step2: Each instance of Domain class has attribute iterator
Step3: Each item is ConfigAlias
Step4: Alias is used to create str representation of each value of the domain because they will be used as folder names and to have more readable representation of configs with non-string values.
Alias is __name__ attribute of the value or str representation. One can define custom alias by using KV class.
Step5: You can define the number of times to produce each item of the domain as n_reps parameter of set_iter. Each produced ConfigAlias will have 'repetition' key.
Step6: Also you can define n_iters parameter to define the number of configs that we will get from Domain. By default it is equel to the actual number of unique elements.
Step7: Operations
Multiplication
The resulting Domain will produce configs from Cartesian product of values. It means that we will get all possible combinations of Option values. Here and below we will pop 'repetition' key from configs to make cell output simpler except the cases while n_reps != 1.
Step8: Sum
Plus unites lists of values.
Step9: @ multiplication
Result is a scalar product of options.
Step10: You also can combine all operations because all of them can be applied to resulting domains.
Step11: size attribute will return the size of resulting domain
Step12: Note that you will get the total number of produced confgs. For example, if you have one Option with two values and n_iters=5 and n_reps=2 in set_iter then the size will be 10.
Step13: Options with Samplers
Instead of array-like options you can use Sampler instances as Option value. Iterator will produce independent samples from domain.
Step14: If n_reps > 1 then samples will be repeated.
Step15: If set_iter will be called with n_iters=None then resulting iterator will be infinite.
Step16: repeat_each parameter defines how often elements from infinite generator will be repeated (by default, repeat_each=100).
Step17: If one multiply array-like options and sampler options, resulting iterator will produce combinations of array-like options with independent sampler from sampler options.
Step18: Domains with Weights
By default configs are consequently produced from option in a sum from the left to the right.
Step19: To sample options from sum independently with some probabilities you can multiply corresponding options by float.
Step20: If you sum options with and without weights,
* they are grouped into consequent groups where all options has or not weights,
* consequently for each group configs are generated consequently (for groups with weights) or sampled as described above.
Step21: Thus, we firstly get all configs from op1, then configs uniformly sampled from op2 and op3. Obviously, if we define some weight too large, firstly we get all samples from corresponding option.
Step22: Consider more dificult situation. We will get
* all configs from options[0]
* configs will be sampled from 1.2 * options[1] + 2.3 * options[2]
* all configs from options[3]
* configs will be sampled from 1.7 * options[4] + 3.4 * options[5] | Python Code:
import sys
import os
import shutil
import matplotlib
%matplotlib inline
sys.path.append('../../..')
from batchflow import NumpySampler as NS
from batchflow.research import KV, Option, Domain
def drop_repetition(config_alias):
res = []
for item in config_alias:
item.pop_alias('repetition')
res.append(item)
return res
Explanation: Advanced Usage of Domain
Domain and auxiliary classes (KV, Option, ConfigAlias) are used to define combinations of parameters to try in Research.
We start with some useful imports and constant definitions
End of explanation
domain = Domain(Option('p', ['v1', 'v2']))
Explanation: Basic usage
Option is a class for parameter name and values that will be used in a Research. Values of the Option can be defined as array or Sampler. Can be easily transformed to Domain to construct iterator which will produce configs.
End of explanation
list(domain.iterator)
Explanation: Each instance of Domain class has attribute iterator: generator which produces configs from the domain.
End of explanation
domain.set_iter()
config = next(domain.iterator)
config.config(), config.alias()
Explanation: Each item is ConfigAlias: wrapper for Config with methods config and alias, methods return wrapped Config and corresponding dict with str representations of values.
To set or reset iterator use set_iter method. It also accepts some parameters that will be described below.
If you get attribute iterator without set_iter, firstly it will be called with default parameters.
End of explanation
domain = Domain(Option('p', [ KV('v1', 'alias'), NS]))
config = next(domain.iterator)
print('alias: {:14} value: {}'.format(config.alias()['p'], config.config()['p']))
config = next(domain.iterator)
print('alias: {:14} value: {}'.format(config.alias()['p'], config.config()['p']))
Explanation: Alias is used to create str representation of each value of the domain because they will be used as folder names and to have more readable representation of configs with non-string values.
Alias is __name__ attribute of the value or str representation. One can define custom alias by using KV class.
End of explanation
domain.set_iter(n_reps=2)
list(domain.iterator)
Explanation: You can define the number of times to produce each item of the domain as n_reps parameter of set_iter. Each produced ConfigAlias will have 'repetition' key.
End of explanation
domain.set_iter(n_iters=3, n_reps=2)
list(domain.iterator)
Explanation: Also you can define n_iters parameter to define the number of configs that we will get from Domain. By default it is equel to the actual number of unique elements.
End of explanation
domain = Option('p1', ['v1', 'v2']) * Option('p2', ['v3', 'v4'])
drop_repetition(domain.iterator)
Explanation: Operations
Multiplication
The resulting Domain will produce configs from Cartesian product of values. It means that we will get all possible combinations of Option values. Here and below we will pop 'repetition' key from configs to make cell output simpler except the cases while n_reps != 1.
End of explanation
domain = Option('p1', ['v1', 'v2']) + Option('p2', ['v3', 'v4'])
drop_repetition(domain.iterator)
Explanation: Sum
Plus unites lists of values.
End of explanation
op1 = Option('p1', ['v1', 'v2'])
op2 = Option('p2', ['v3', 'v4'])
op3 = Option('p3', ['v5', 'v6'])
domain = op1 @ op2 @ op3
drop_repetition(domain.iterator)
Explanation: @ multiplication
Result is a scalar product of options.
End of explanation
op1 = Option('p1', ['v1', 'v2'])
op2 = Option('p2', ['v3', 'v4'])
op3 = Option('p3', list(range(2)))
op4 = Option('p4', list(range(3, 5)))
domain = (op1 @ op2 + op3) * op4
drop_repetition(domain.iterator)
Explanation: You also can combine all operations because all of them can be applied to resulting domains.
End of explanation
print(domain.size)
Explanation: size attribute will return the size of resulting domain
End of explanation
domain = Domain(Option('p1', list(range(3))))
domain.set_iter(n_iters=5, n_reps=2)
domain.size
Explanation: Note that you will get the total number of produced confgs. For example, if you have one Option with two values and n_iters=5 and n_reps=2 in set_iter then the size will be 10.
End of explanation
domain = Domain(Option('p1', NS('n')))
domain.set_iter(n_iters=3)
drop_repetition(domain.iterator)
Explanation: Options with Samplers
Instead of array-like options you can use Sampler instances as Option value. Iterator will produce independent samples from domain.
End of explanation
domain.set_iter(n_iters=3, n_reps=2)
list(domain.iterator)
Explanation: If n_reps > 1 then samples will be repeated.
End of explanation
domain.set_iter(n_iters=None)
print('size: ', domain.size)
for _ in range(5):
print(next(domain.iterator))
Explanation: If set_iter will be called with n_iters=None then resulting iterator will be infinite.
End of explanation
domain.set_iter(n_iters=None, n_reps=2, repeat_each=2)
print('Domain size: {} \n'.format(domain.size))
for _ in range(8):
print(next(domain.iterator))
Explanation: repeat_each parameter defines how often elements from infinite generator will be repeated (by default, repeat_each=100).
End of explanation
domain = Option('p1', NS('n')) * Option('p2', NS('u')) * Option('p3', [1, 2, 3])
drop_repetition(domain.iterator)
Explanation: If one multiply array-like options and sampler options, resulting iterator will produce combinations of array-like options with independent sampler from sampler options.
End of explanation
op1 = Option('p1', ['v1', 'v2'])
op2 = Option('p2', ['v3', 'v4'])
op3 = Option('p3', ['v5', 'v6'])
domain = op1 + op2 + op3
drop_repetition(domain.iterator)
Explanation: Domains with Weights
By default configs are consequently produced from option in a sum from the left to the right.
End of explanation
domain = 0.3 * op1 + 0.2 * op2 + 0.5 * op3
drop_repetition(domain.iterator)
Explanation: To sample options from sum independently with some probabilities you can multiply corresponding options by float.
End of explanation
domain = op1 + 1.0 * op2 + 1.0 * op3
drop_repetition(domain.iterator)
Explanation: If you sum options with and without weights,
* they are grouped into consequent groups where all options has or not weights,
* consequently for each group configs are generated consequently (for groups with weights) or sampled as described above.
End of explanation
domain = op1 + 1.0 * op2 + 100.0 * op3
drop_repetition(domain.iterator)
Explanation: Thus, we firstly get all configs from op1, then configs uniformly sampled from op2 and op3. Obviously, if we define some weight too large, firstly we get all samples from corresponding option.
End of explanation
options = [Option('p'+str(i), ['v'+str(i)]) for i in range(6)]
domain = options[0] + 1.2 * options[1] + 2.3 * options[2] + options[3] + 1.7 * options[4] + 3.4 * options[5]
domain.set_iter(12)
drop_repetition(domain.iterator)
Explanation: Consider more dificult situation. We will get
* all configs from options[0]
* configs will be sampled from 1.2 * options[1] + 2.3 * options[2]
* all configs from options[3]
* configs will be sampled from 1.7 * options[4] + 3.4 * options[5]
End of explanation |
3,475 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Lab session 1
Step1: The current draft of the online documentation of GPy is available from this page.
Let's start with defining an exponentiated quadratic covariance function (also known as squared exponential or rbf or Gaussian) in one dimension
Step2: A summary of the kernel can be obtained using the command print k.
Step3: It is also possible to plot the kernel as a function of one of its inputs (whilst fixing the other) with k.plot().
Note
Step4: Setting Covariance Function Parameters
The value of the covariance function parameters can be accessed and modified using k['.*var'] where the string in bracket is a regular expression matching the parameter name as it appears in print k. Let's use this to get an insight into the effect of the parameters on the shape of the covariance function.
We'll now use to set the lengthscale of the covariance to different values, and then plot the resulting covariance using the k.plot() method.
Step5: Exercise 1
a) What is the effect of the lengthscale parameter on the covariance function?
b) Now change the code used above for plotting the covariances associated with the length scale to see the influence of the variance parameter. What is the effect of the the variance parameter on the covariance function?
Step6: Covariance Functions in GPy
Many covariance functions are already implemented in GPy. Instead of rbf, try constructing and plotting the following covariance functions
Step7: Computing the Covariance Function given the Input Data, $\mathbf{X}$
Let $\mathbf{X}$ be a $n$ × $d$ numpy array. Given a kernel $k$, the covariance matrix associated to
$\mathbf{X}$ is obtained with C = k.K(X,X) . The positive semi-definiteness of $k$ ensures that C
is a positive semi-definite (psd) matrix regardless of the initial points $\mathbf{X}$. This can be
checked numerically by looking at the eigenvalues
Step8: Combining Covariance Functions
Exercise 2
a) A matrix, $\mathbf{K}$, is positive semi-definite if the matrix inner product, $\mathbf{x}^\top \mathbf{K}\mathbf{x}$ is greater than or equal to zero regardless of the values in $\mathbf{x}$. Given this it should be easy to see that the sum of two positive semi-definite matrices is also positive semi-definite. In the context of Gaussian processes, this is the sum of two covariance functions. What does this mean from a modelling perspective?
Hint
Step9: Or if we wanted to multiply them we can write
Step10: 2 Sampling from a Gaussian Process
The Gaussian process provides a prior over an infinite dimensional function. It is defined by a covariance function and a mean function. When we compute the covariance matrix using kern.K(X, X) we are computing a covariance matrix between the values of the function that correspond to the input locations in the matrix X. If we want to have a look at the type of functions that arise from a particular Gaussian process we can never generate all values of the function, because there are infinite values. However, we can generate samples from a Gaussian distribution based on a covariance matrix associated with a particular matrix of input locations X. If these locations are chosen appropriately then they give us a good idea of the underlying function. For example, for a one dimensional function, if we choose X to be uniformly spaced across part of the real line, and the spacing is small enough, we'll get an idea of the underlying function. We will now use this trick to draw sample paths from a Gaussian process.
Step11: Our choice of X means that the points are close enough together to look like functions. We can see the structure of the covariance matrix we are plotting from if we visualize C.
Step12: Now try a range of different covariance functions and values and plot the corresponding sample paths for each using the same approach given above.
Step13: Exercise 3
Can you tell the covariance structures that have been used for generating the
sample paths shown in the figure below?
<br>
<center>
<img src="http
Step14: A GP regression model based on an exponentiated quadratic covariance function can be defined by first defining a covariance function,
Step15: And then combining it with the data to form a Gaussian process model,
Step16: Just as for the covariance function object, we can find out about the model using the command print m.
Step17: Note that by default the model includes some observation noise
with variance 1. We can see the posterior mean prediction and visualize the marginal posterior variances using m.plot().
Step18: The actual predictions of the model for a set of points Xstar
(an $m \times p$ array) can be computed using Ystar, Vstar, up95, lo95 = m.predict(Xstar)
Exercise 4
a) What do you think about this first fit? Does the prior given by the GP seem to be
adapted?
b) The parameters of the models can be modified using a regular expression matching the parameters names (for example m['noise'] = 0.001 ). Change the values of the parameters to obtain a better fit.
Step19: c) As in Section 2, random sample paths from the conditional GP can be obtained using
np.random.multivariate_normal(mu[
Step20: Covariance Function Parameter Estimation
As we have seen during the lectures, the parameters values can be estimated by maximizing the likelihood of the observations. Since we don’t want one of the variance to become negative during the optimization, we can constrain all parameters to be positive before running the optimisation.
Step21: The warnings are because the parameters are already constrained by default, the software is warning us that they are being reconstrained.
Now we can optimize the model using the m.optimize() method.
Step22: The parameters obtained after optimisation can be compared with the values selected by hand above. As previously, you can modify the kernel used for building the model to investigate its influence on the model.
4 A Running Example
Now we'll consider a small example with real world data, data giving the pace of all marathons run at the olympics. To load the data use
Step23: Exercise 5
a) Build a Gaussian process model for the olympic data set using a combination of an exponentiated quadratic and a bias covariance function. Fit the covariance function parameters and the noise to the data. Plot the fit and error bars from 1870 to 2030. Do you think the predictions are reasonable? If not why not?
Step24: b) Fit the same model, but this time intialize the length scale of the exponentiated quadratic to 0.5. What has happened? Which of model has the higher log likelihood, this one or the one from (a)?
Hint
Step25: c) Modify your model by including two covariance functions. Intitialize a covariance function with an exponentiated quadratic part, a Matern 3/2 part and a bias covariance. Set the initial lengthscale of the exponentiated quadratic to 80 years, set the initial length scale of the Matern 3/2 to 10 years. Optimize the new model and plot the fit again. How does it compare with the previous model?
Step26: d) Repeat part c) but now initialize both of the covariance functions' lengthscales to 20 years. Check the model parameters, what happens now?
Step27: e) Now model the data with a product of an exponentiated quadratic covariance function and a linear covariance function. Fit the covariance function parameters. Why are the variance parameters of the linear part so small? How could this be fixed?
Step28: 5 More Advanced
Step29: We assume here that we are interested in the distribution of $f (U )$ where $U$ is a
random variable with uniform distribution over the input space of $f$. We will focus on
the computation of two quantities
Step30: Exercise 6
a) Has the approximation of the mean been improved by using the GP model?
b) One particular feature of GPs we have not use for now is their prediction variance. Can you use it to define some confidence intervals around the previous result?
Step31: 4.2 Computation of $P( f (U ) > 200)$
In various cases it is interesting to look at the probability that $f$ is greater than a given
threshold. For example, assume that $f$ is the response of a physical model representing
the maximum constraint in a structure depending on some parameters of the system
such as Young’s modulus of the material (say $Y$) and the force applied on the structure
(say $F$). If the later are uncertain, the probability of failure of the structure is given by
$P( f (Y, F ) > \text{f_max} )$ where $f_\text{max}$ is the maximum acceptable constraint.
Exercise 7
a) As previously, use the 25 observations to compute a rough estimate of the probability that $f (U ) > 200$.
Step32: b) Compute the probability that the best predictor is greater than the threshold.
Step33: c) Compute some confidence intervals for the previous result
Step34: These two values can be compared with the actual value {$P( f (U ) > 200) = 1.23\times 10^{−2}$ .
We now assume that we have an extra budget of 10 evaluations of f and we want to
use these new evaluations to improve the accuracy of the previous result.
Exercise 8
a) Given the previous GP model, where is it interesting to add the new observations if we want to improve the accuracy of the estimator and reduce its variance?
b) Can you think about (and implement!) a procedure that updates sequentially the model with new points in order to improve the estimation of $P( f (U ) > 200)$? | Python Code:
%matplotlib inline
import numpy as np
from matplotlib import pyplot as plt
import GPy
Explanation: Lab session 1: Gaussian Process models with GPy
Gaussian Process Summer School, 14th Semptember 2015
written by Nicolas Durrande, Neil Lawrence and James Hensman
The aim of this lab session is to illustrate the concepts seen during the lectures. We will focus on three aspects of GPs: the kernel, the random sample paths and the GP regression model.
Since the background of the attendees is very diverse, this session will attempt to cover a large spectrum from the very basic of GPs to more technical questions. This in mind, the difficulties of the questions of the lab session varies. We do not mark these labs in any way, you should focus on the parts that you find most useful. In this session you should complete at least as far as Exercise 5.
1 Getting started: The Covariance Function
We assume that GPy is already installed on your machine. You can get instructions on how to install GPy from the SheffieldML github page. They are written as markdown in the README.md file, which is automatically parsed for you just under the file listing there.
We first tell the ipython notebook that we want the plots to appear inline, then we import the libraries we will need:
End of explanation
d = 1 # input dimension
var = 1. # variance
theta = 0.2 # lengthscale
k = GPy.kern.RBF(d, variance=var, lengthscale=theta)
Explanation: The current draft of the online documentation of GPy is available from this page.
Let's start with defining an exponentiated quadratic covariance function (also known as squared exponential or rbf or Gaussian) in one dimension:
End of explanation
print k
Explanation: A summary of the kernel can be obtained using the command print k.
End of explanation
k.plot()
Explanation: It is also possible to plot the kernel as a function of one of its inputs (whilst fixing the other) with k.plot().
Note: if you need help with a command in ipython notebook, then you can get it at any time by typing a question mark after the command, e.g. k.plot?
End of explanation
k = GPy.kern.RBF(d) # By default, the parameters are set to 1.
theta = np.asarray([0.2,0.5,1.,2.,4.])
for t in theta:
k.lengthscale=t
k.plot()
plt.legend(theta)
Explanation: Setting Covariance Function Parameters
The value of the covariance function parameters can be accessed and modified using k['.*var'] where the string in bracket is a regular expression matching the parameter name as it appears in print k. Let's use this to get an insight into the effect of the parameters on the shape of the covariance function.
We'll now use to set the lengthscale of the covariance to different values, and then plot the resulting covariance using the k.plot() method.
End of explanation
k = GPy.kern.RBF(d) # By default, the parameters are set to 1.
theta = np.asarray([1.0, 2.0, 4.0, 8.0])
for t in theta:
k.variance=t
k.plot()
plt.legend(theta)
Explanation: Exercise 1
a) What is the effect of the lengthscale parameter on the covariance function?
b) Now change the code used above for plotting the covariances associated with the length scale to see the influence of the variance parameter. What is the effect of the the variance parameter on the covariance function?
End of explanation
kb = GPy.kern.Brownian(input_dim=1)
inputs = np.array([2., 4.])
for x in inputs:
kb.plot(x,plot_limits=[0,5])
plt.legend(inputs)
plt.ylim(-0.1,5.1)
Explanation: Covariance Functions in GPy
Many covariance functions are already implemented in GPy. Instead of rbf, try constructing and plotting the following covariance functions: exponential, Matern32, Matern52, Brownian, linear, bias,
rbfcos, periodic_Matern32, etc. Some of these covariance functions, such as rbfcos, are not
parametrized by a variance and a lengthscale. Furthermore, not all kernels are stationary (i.e., they can’t all be written as $k ( x, y) = f ( x − y)$, see for example the Brownian
covariance function). For plotting so it may be interesting to change the value of the fixed input:
End of explanation
k = GPy.kern.Matern52(input_dim=2)
X = np.random.rand(50,2) # 50*2 matrix of iid standard Gaussians
C = k.K(X,X)
eigvals = np.linalg.eigvals(C) # Computes the eigenvalues of a matrix
plt.bar(np.arange(len(eigvals)), eigvals)
plt.title('Eigenvalues of the Matern 5/2 Covariance')
Explanation: Computing the Covariance Function given the Input Data, $\mathbf{X}$
Let $\mathbf{X}$ be a $n$ × $d$ numpy array. Given a kernel $k$, the covariance matrix associated to
$\mathbf{X}$ is obtained with C = k.K(X,X) . The positive semi-definiteness of $k$ ensures that C
is a positive semi-definite (psd) matrix regardless of the initial points $\mathbf{X}$. This can be
checked numerically by looking at the eigenvalues:
End of explanation
kern1 = GPy.kern.RBF(1, variance=1., lengthscale=2.)
kern2 = GPy.kern.Matern52(1, variance=2., lengthscale=4.)
kern = kern1 + kern2
print kern
kern.plot()
Explanation: Combining Covariance Functions
Exercise 2
a) A matrix, $\mathbf{K}$, is positive semi-definite if the matrix inner product, $\mathbf{x}^\top \mathbf{K}\mathbf{x}$ is greater than or equal to zero regardless of the values in $\mathbf{x}$. Given this it should be easy to see that the sum of two positive semi-definite matrices is also positive semi-definite. In the context of Gaussian processes, this is the sum of two covariance functions. What does this mean from a modelling perspective?
Hint: there are actually two related interpretations for this. Think about the properties of a Gaussian distribution, and where the sum of Gaussian variances arises.
What about the element-wise product of two covariance functions? In other words if we define
\begin{align}
k(\mathbf{x}, \mathbf{x}^\prime) = k_1(\mathbf{x}, \mathbf{x}^\prime) k_2(\mathbf{x}, \mathbf{x}^\prime)
\end{align}
then is $k(\mathbf{x}, \mathbf{x}^\prime)$ a valid covariance function?
Combining Covariance Functions in GPy
In GPy you can easily combine covariance functions you have created using the sum and product operators, + and *. So, for example, if we wish to combine an exponentiated quadratic covariance with a Matern 5/2 then we can write
End of explanation
kern = kern1*kern2
print kern
kern.plot()
Explanation: Or if we wanted to multiply them we can write
End of explanation
k = GPy.kern.RBF(input_dim=1,lengthscale=0.2)
X = np.linspace(0.,1.,500) # define X to be 500 points evenly spaced over [0,1]
X = X[:,None] # reshape X to make it n*p --- we try to use 'design matrices' in GPy
mu = np.zeros((500)) # vector of the means --- we could use a mean function here, but here it is just zero.
C = k.K(X,X) # compute the covariance matrix associated with inputs X
_ = plt.imshow(C)
help(np.random.multivariate_normal)
# Generate 20 separate samples paths from a Gaussian with mean mu and covariance C
Z = np.random.multivariate_normal(mu,C,20)
plt.figure() # open a new plotting window
for i in range(20):
plt.plot(X[:],Z[i,:])
Explanation: 2 Sampling from a Gaussian Process
The Gaussian process provides a prior over an infinite dimensional function. It is defined by a covariance function and a mean function. When we compute the covariance matrix using kern.K(X, X) we are computing a covariance matrix between the values of the function that correspond to the input locations in the matrix X. If we want to have a look at the type of functions that arise from a particular Gaussian process we can never generate all values of the function, because there are infinite values. However, we can generate samples from a Gaussian distribution based on a covariance matrix associated with a particular matrix of input locations X. If these locations are chosen appropriately then they give us a good idea of the underlying function. For example, for a one dimensional function, if we choose X to be uniformly spaced across part of the real line, and the spacing is small enough, we'll get an idea of the underlying function. We will now use this trick to draw sample paths from a Gaussian process.
End of explanation
plt.matshow(C)
Explanation: Our choice of X means that the points are close enough together to look like functions. We can see the structure of the covariance matrix we are plotting from if we visualize C.
End of explanation
# Try plotting sample paths here
Explanation: Now try a range of different covariance functions and values and plot the corresponding sample paths for each using the same approach given above.
End of explanation
np.random.normal?
X = np.linspace(0.05,0.95,10)[:,None]
Y = -np.cos(np.pi*X) + np.sin(4*np.pi*X) + np.random.normal(loc=0.0, scale=0.1, size=(10,1))
plt.figure()
plt.plot(X,Y,'kx',mew=1.5)
Explanation: Exercise 3
Can you tell the covariance structures that have been used for generating the
sample paths shown in the figure below?
<br>
<center>
<img src="http://ml.dcs.shef.ac.uk/gpss/gpws14/figa.png" alt="Figure a" style="width: 30%;">
<img src="http://ml.dcs.shef.ac.uk/gpss/gpws14/figb.png" alt="Figure b" style="width: 30%;">
<img src="http://ml.dcs.shef.ac.uk/gpss/gpws14/figc.png" alt="Figure c" style="width: 30%;">
<img src="http://ml.dcs.shef.ac.uk/gpss/gpws14/figd.png" alt="Figure d" style="width: 30%;">
<img src="http://ml.dcs.shef.ac.uk/gpss/gpws14/fige.png" alt="Figure e" style="width: 30%;">
<img src="http://ml.dcs.shef.ac.uk/gpss/gpws14/figf.png" alt="Figure f" style="width: 30%;">
</center>
3 A Gaussian Process Regression Model
We will now combine the Gaussian process prior with some data to form a GP regression model with GPy. We will generate data from the function $f ( x ) = − \cos(\pi x ) + \sin(4\pi x )$ over $[0, 1]$, adding some noise to give $y(x) = f(x) + \epsilon$, with the noise being Gaussian distributed, $\epsilon \sim \mathcal{N}(0, 0.01)$.
End of explanation
k = GPy.kern.RBF(input_dim=1, variance=1., lengthscale=1.)
Explanation: A GP regression model based on an exponentiated quadratic covariance function can be defined by first defining a covariance function,
End of explanation
m = GPy.models.GPRegression(X,Y,k)
Explanation: And then combining it with the data to form a Gaussian process model,
End of explanation
print m
Explanation: Just as for the covariance function object, we can find out about the model using the command print m.
End of explanation
m.plot()
Explanation: Note that by default the model includes some observation noise
with variance 1. We can see the posterior mean prediction and visualize the marginal posterior variances using m.plot().
End of explanation
# Exercise 4 b) answer
Explanation: The actual predictions of the model for a set of points Xstar
(an $m \times p$ array) can be computed using Ystar, Vstar, up95, lo95 = m.predict(Xstar)
Exercise 4
a) What do you think about this first fit? Does the prior given by the GP seem to be
adapted?
b) The parameters of the models can be modified using a regular expression matching the parameters names (for example m['noise'] = 0.001 ). Change the values of the parameters to obtain a better fit.
End of explanation
# Exercise 4 c) answer
Explanation: c) As in Section 2, random sample paths from the conditional GP can be obtained using
np.random.multivariate_normal(mu[:,0],C) where the mean vector and covariance
matrix mu, C are obtained through the predict function mu, C, up95, lo95 = m.predict(Xp,full_cov=True). Obtain 10 samples from the posterior sample and plot them alongside the data below.
End of explanation
m.constrain_positive()
Explanation: Covariance Function Parameter Estimation
As we have seen during the lectures, the parameters values can be estimated by maximizing the likelihood of the observations. Since we don’t want one of the variance to become negative during the optimization, we can constrain all parameters to be positive before running the optimisation.
End of explanation
m.optimize()
m.plot()
print m
Explanation: The warnings are because the parameters are already constrained by default, the software is warning us that they are being reconstrained.
Now we can optimize the model using the m.optimize() method.
End of explanation
GPy.util.datasets.authorize_download = lambda x: True # prevents requesting authorization for download.
data = GPy.util.datasets.olympic_marathon_men()
print data['details']
X = data['X']
Y = data['Y']
plt.plot(X, Y, 'bx')
plt.xlabel('year')
plt.ylabel('marathon pace min/km')
Explanation: The parameters obtained after optimisation can be compared with the values selected by hand above. As previously, you can modify the kernel used for building the model to investigate its influence on the model.
4 A Running Example
Now we'll consider a small example with real world data, data giving the pace of all marathons run at the olympics. To load the data use
End of explanation
# Exercise 5 a) answer
kern = GPy.kern.RBF(1) + GPy.kern.Bias(1)
model = GPy.models.GPRegression(X, Y, kern)
model.optimize()
model.plot()# Exercise 5 d) answer
model.log_likelihood()
Explanation: Exercise 5
a) Build a Gaussian process model for the olympic data set using a combination of an exponentiated quadratic and a bias covariance function. Fit the covariance function parameters and the noise to the data. Plot the fit and error bars from 1870 to 2030. Do you think the predictions are reasonable? If not why not?
End of explanation
# Exercise 5 b) answer
Explanation: b) Fit the same model, but this time intialize the length scale of the exponentiated quadratic to 0.5. What has happened? Which of model has the higher log likelihood, this one or the one from (a)?
Hint: use model.log_likelihood() for computing the log likelihood.
End of explanation
# Exercise 5 c) answer
Explanation: c) Modify your model by including two covariance functions. Intitialize a covariance function with an exponentiated quadratic part, a Matern 3/2 part and a bias covariance. Set the initial lengthscale of the exponentiated quadratic to 80 years, set the initial length scale of the Matern 3/2 to 10 years. Optimize the new model and plot the fit again. How does it compare with the previous model?
End of explanation
# Exercise 5 d) answer
Explanation: d) Repeat part c) but now initialize both of the covariance functions' lengthscales to 20 years. Check the model parameters, what happens now?
End of explanation
# Exercise 5 e) answer
Explanation: e) Now model the data with a product of an exponentiated quadratic covariance function and a linear covariance function. Fit the covariance function parameters. Why are the variance parameters of the linear part so small? How could this be fixed?
End of explanation
# Definition of the Branin test function
def branin(X):
y = (X[:,1]-5.1/(4*np.pi**2)*X[:,0]**2+5*X[:,0]/np.pi-6)**2
y += 10*(1-1/(8*np.pi))*np.cos(X[:,0])+10
return(y)
# Training set defined as a 5*5 grid:
xg1 = np.linspace(-5,10,5)
xg2 = np.linspace(0,15,5)
X = np.zeros((xg1.size * xg2.size,2))
for i,x1 in enumerate(xg1):
for j,x2 in enumerate(xg2):
X[i+xg1.size*j,:] = [x1,x2]
Y = branin(X)[:,None]
Explanation: 5 More Advanced: Uncertainty propagation
Let $x$ be a random variable defined over the real numbers, $\Re$, and $f(\cdot)$ be a function mapping between the real numbers $\Re \rightarrow \Re$. Uncertainty
propagation is the study of the distribution of the random variable $f ( x )$.
We will see in this section the advantage of using a model when only a few observations of $f$ are available. We consider here the 2-dimensional Branin test function
defined over [−5, 10] × [0, 15] and a set of 25 observations as seen in Figure 3.
End of explanation
# Fit a GP
# Create an exponentiated quadratic plus bias covariance function
kg = GPy.kern.RBF(input_dim=2, ARD = True)
kb = GPy.kern.Bias(input_dim=2)
k = kg + kb
# Build a GP model
m = GPy.models.GPRegression(X,Y,k)
# fix the noise variance
m.likelihood.variance.fix(1e-5)
# Randomize the model and optimize
m.randomize()
m.optimize()
# Plot the resulting approximation to Brainin
# Here you get a two-d plot becaue the function is two dimensional.
m.plot()
# Compute the mean of model prediction on 1e5 Monte Carlo samples
Xp = np.random.uniform(size=(1e5,2))
Xp[:,0] = Xp[:,0]*15-5
Xp[:,1] = Xp[:,1]*15
mu, var = m.predict(Xp)
np.mean(mu)
Explanation: We assume here that we are interested in the distribution of $f (U )$ where $U$ is a
random variable with uniform distribution over the input space of $f$. We will focus on
the computation of two quantities: $E[ f (U )]$ and $P( f (U ) > 200)$.
4.1 Computation of E[ f (U )]
The expectation of $f (U )$ is given by $\int_x f ( x )\text{d}x$. A basic approach to approximate this
integral is to compute the mean of the 25 observations: np.mean(Y). Since the points
are distributed on a grid, this can be seen as the approximation of the integral by a
rough Riemann sum. The result can be compared with the actual mean of the Branin
function which is 54.31.
Alternatively, we can fit a GP model and compute the integral of the best predictor
by Monte Carlo sampling:
End of explanation
# Exercise 6 b) answer
Explanation: Exercise 6
a) Has the approximation of the mean been improved by using the GP model?
b) One particular feature of GPs we have not use for now is their prediction variance. Can you use it to define some confidence intervals around the previous result?
End of explanation
# Exercise 7 a) answer
Explanation: 4.2 Computation of $P( f (U ) > 200)$
In various cases it is interesting to look at the probability that $f$ is greater than a given
threshold. For example, assume that $f$ is the response of a physical model representing
the maximum constraint in a structure depending on some parameters of the system
such as Young’s modulus of the material (say $Y$) and the force applied on the structure
(say $F$). If the later are uncertain, the probability of failure of the structure is given by
$P( f (Y, F ) > \text{f_max} )$ where $f_\text{max}$ is the maximum acceptable constraint.
Exercise 7
a) As previously, use the 25 observations to compute a rough estimate of the probability that $f (U ) > 200$.
End of explanation
# Exercise 7 b) answer
Explanation: b) Compute the probability that the best predictor is greater than the threshold.
End of explanation
# Exercise 7 c) answer
Explanation: c) Compute some confidence intervals for the previous result
End of explanation
# Exercise 8 b) answer
Explanation: These two values can be compared with the actual value {$P( f (U ) > 200) = 1.23\times 10^{−2}$ .
We now assume that we have an extra budget of 10 evaluations of f and we want to
use these new evaluations to improve the accuracy of the previous result.
Exercise 8
a) Given the previous GP model, where is it interesting to add the new observations if we want to improve the accuracy of the estimator and reduce its variance?
b) Can you think about (and implement!) a procedure that updates sequentially the model with new points in order to improve the estimation of $P( f (U ) > 200)$?
End of explanation |
3,476 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Reading data into Astropy Tables
Objectives
Read ASCII files with a defined format
Learn basic operations with astropy.tables
Ingest header information
VOTables
Reading data
Our first task with python was to read a csv file using np.loadtxt().
That function has few properties to define the dlimiter of the columns, skip rows, read commented lines, convert values while reading, etc.
However, the result is an array, without the information of the metadata that file may have included (name, units, ...).
Astropy offers a ascii reader that improves many of these steps while provides templates to read common ascii files in astronomy.
Step1: Automatically, read has identified the header and the format of each column. The result is a Table object, and that brings some additional properties.
Step2: Astropy can read a variety of formats easily.
The following example uses a quite
Step4: Properties when reading
the reading of the table has many properties, let's imagine the following easy example
Step5: When the values are not empty, then the keyword fill_values on read has to be used.
Reading VOTables
VOTables are an special type of tables which should be self-consistent and can be tied to a particular scheme.
This mean the file will contain where the data comes from (and which query produced it) and the properties for each field, making it easier to ingest by a machine. | Python Code:
from astropy.io import ascii
# Read a sample file: sources.dat
data = ascii.read("sources.dat")
data
Explanation: Reading data into Astropy Tables
Objectives
Read ASCII files with a defined format
Learn basic operations with astropy.tables
Ingest header information
VOTables
Reading data
Our first task with python was to read a csv file using np.loadtxt().
That function has few properties to define the dlimiter of the columns, skip rows, read commented lines, convert values while reading, etc.
However, the result is an array, without the information of the metadata that file may have included (name, units, ...).
Astropy offers a ascii reader that improves many of these steps while provides templates to read common ascii files in astronomy.
End of explanation
# Show the info of the data read
data.info
# Get the name of the columns
data.colnames
# Get just the values of a particular column
data['obsid']
# get the first element
data['obsid', 'redshift'][0]
Explanation: Automatically, read has identified the header and the format of each column. The result is a Table object, and that brings some additional properties.
End of explanation
# Read the data from the source
table = ascii.read("ftp://cdsarc.u-strasbg.fr/pub/cats/VII/253/snrs.dat",
readme="ftp://cdsarc.u-strasbg.fr/pub/cats/VII/253/ReadMe")
# See the stats of the table
table.info('stats')
# If we want to see the first 10 entries
table[0:10]
# the units are also stored, we can extract them too
table['MajDiam'].quantity.to('rad')[0:3]
# Adding values of different columns
(table['RAh'] + table['RAm'] + table['RAs'])[0:3]
# adding values of different columns but being aware of column units
(table['RAh'].quantity + table['RAm'].quantity + table['RAs'].quantity)[0:3]
# Create a new column in the table
table['RA'] = table['RAh'].quantity + table['RAm'].quantity + table['RAs'].quantity
# Show table's new column
table['RA'][0:3]
# add a description to the new column
table['RA'].description = table['RAh'].description
# Now it does show the values
table['RA'][0:3]
# Using numpy to calculate the sin of the RA
import numpy as np
np.sin(table['RA'].quantity)
# Let's change the units...
import astropy.units as u
table['RA'].unit = u.hourangle
# does the sin now works?
np.sin(table['RA'].quantity)
Explanation: Astropy can read a variety of formats easily.
The following example uses a quite
End of explanation
weather_data =
# Country = Finland
# City = Helsinki
# Longitud = 24.9375
# Latitud = 60.170833
# Week = 32
# Year = 2015
day, precip, type
Mon,1.5,rain
Tues,,
Wed,1.1,snow
Thur,2.3,rain
Fri,0.2,
Sat,1.1,snow
Sun,5.4,snow
# Read the table
weather = ascii.read(weather_data)
# Blank values are interpreted by default as bad/missing values
weather.info('stats')
# Let's define missing values for the columns we want:
weather['type'].fill_value = 'N/A'
weather['precip'].fill_value = -999
# Use filled to show the value filled.
weather.filled()
# We can see the meta as a dictionary, but not as key, value pairs
weather.meta
# To get it the header as a table
header = ascii.read(weather.meta['comments'], delimiter='=',
format='no_header', names=['key', 'val'])
print(header)
Explanation: Properties when reading
the reading of the table has many properties, let's imagine the following easy example:
End of explanation
from astropy.io.votable import parse_single_table
# Read the example table from HELIO (hfc_ar.xml)
table = parse_single_table("hfc_ar.xml")
# See the fields of the table
table.fields
# extract one (NOAA_NUMBER) or all of the columns
NOAA = table.array['NOAA_NUMBER']
# Show the data
NOAA.data
# See the mask
NOAA.mask
# Shee the whole array.
NOAA
# Convert the table to an astropy table
asttable = table.to_table()
# See the table
asttable
# Different results because quantities are not
print(np.sin(asttable['FEAT_HG_LAT_DEG'][0:5]))
print(np.sin(asttable['FEAT_HG_LAT_DEG'][0:5].quantity))
# And it can also be converted to other units
print(asttable[0:5]['FEAT_AREA_DEG2'].quantity.to('arcmin2'))
Explanation: When the values are not empty, then the keyword fill_values on read has to be used.
Reading VOTables
VOTables are an special type of tables which should be self-consistent and can be tied to a particular scheme.
This mean the file will contain where the data comes from (and which query produced it) and the properties for each field, making it easier to ingest by a machine.
End of explanation |
3,477 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
A Simple Autoencoder
We'll start off by building a simple autoencoder to compress the MNIST dataset. With autoencoders, we pass input data through an encoder that makes a compressed representation of the input. Then, this representation is passed through a decoder to reconstruct the input data. Generally the encoder and decoder will be built with neural networks, then trained on example data.
In this notebook, we'll be build a simple network architecture for the encoder and decoder. Let's get started by importing our libraries and getting the dataset.
Step1: Below I'm plotting an example image from the MNIST dataset. These are 28x28 grayscale images of handwritten digits.
Step2: We'll train an autoencoder with these images by flattening them into 784 length vectors. The images from this dataset are already normalized such that the values are between 0 and 1. Let's start by building basically the simplest autoencoder with a single ReLU hidden layer. This layer will be used as the compressed representation. Then, the encoder is the input layer and the hidden layer. The decoder is the hidden layer and the output layer. Since the images are normalized between 0 and 1, we need to use a sigmoid activation on the output layer to get values matching the input.
Exercise
Step3: Training
Step4: Here I'll write a bit of code to train the network. I'm not too interested in validation here, so I'll just monitor the training loss.
Calling mnist.train.next_batch(batch_size) will return a tuple of (images, labels). We're not concerned with the labels here, we just need the images. Otherwise this is pretty straightfoward training with TensorFlow. We initialize the variables with sess.run(tf.global_variables_initializer()). Then, run the optimizer and get the loss with batch_cost, _ = sess.run([cost, opt], feed_dict=feed).
Step5: Checking out the results
Below I've plotted some of the test images along with their reconstructions. For the most part these look pretty good except for some blurriness in some parts. | Python Code:
%matplotlib inline
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', validation_size=0)
Explanation: A Simple Autoencoder
We'll start off by building a simple autoencoder to compress the MNIST dataset. With autoencoders, we pass input data through an encoder that makes a compressed representation of the input. Then, this representation is passed through a decoder to reconstruct the input data. Generally the encoder and decoder will be built with neural networks, then trained on example data.
In this notebook, we'll be build a simple network architecture for the encoder and decoder. Let's get started by importing our libraries and getting the dataset.
End of explanation
img = mnist.train.images[2]
plt.imshow(img.reshape((28, 28)), cmap='Greys_r')
Explanation: Below I'm plotting an example image from the MNIST dataset. These are 28x28 grayscale images of handwritten digits.
End of explanation
mnist.train.images.shape[1]
learning_rate = 0.001
image_size = mnist.train.images.shape[1]
# Size of the encoding layer (the hidden layer)
encoding_dim = 32 # feel free to change this value
# Input and target placeholders
inputs_ = tf.placeholder(tf.float32, (None, image_size))
targets_ = tf.placeholder(tf.float32, (None, image_size))
# Output of hidden layer, single fully connected layer here with ReLU activation
encoded = tf.layers.dense(inputs_, encoding_dim, activation=tf.nn.relu)
# Output layer logits, fully connected layer with no activation
logits = tf.layers.dense(encoded, image_size, activation=None)
# Sigmoid output from logits
decoded = tf.nn.sigmoid(logits, name='output')
# Sigmoid cross-entropy loss
loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=targets_, logits=logits)
# Mean of the loss
cost = tf.reduce_mean(loss)
# Adam optimizer
opt = tf.train.AdamOptimizer(learning_rate).minimize(cost)
Explanation: We'll train an autoencoder with these images by flattening them into 784 length vectors. The images from this dataset are already normalized such that the values are between 0 and 1. Let's start by building basically the simplest autoencoder with a single ReLU hidden layer. This layer will be used as the compressed representation. Then, the encoder is the input layer and the hidden layer. The decoder is the hidden layer and the output layer. Since the images are normalized between 0 and 1, we need to use a sigmoid activation on the output layer to get values matching the input.
Exercise: Build the graph for the autoencoder in the cell below. The input images will be flattened into 784 length vectors. The targets are the same as the inputs. And there should be one hidden layer with a ReLU activation and an output layer with a sigmoid activation. Feel free to use TensorFlow's higher level API, tf.layers. For instance, you would use tf.layers.dense(inputs, units, activation=tf.nn.relu) to create a fully connected layer with a ReLU activation. The loss should be calculated with the cross-entropy loss, there is a convenient TensorFlow function for this tf.nn.sigmoid_cross_entropy_with_logits (documentation). You should note that tf.nn.sigmoid_cross_entropy_with_logits takes the logits, but to get the reconstructed images you'll need to pass the logits through the sigmoid function.
End of explanation
# Create the session
sess = tf.Session()
Explanation: Training
End of explanation
epochs = 20
batch_size = 200
sess.run(tf.global_variables_initializer())
for e in range(epochs):
for ii in range(mnist.train.num_examples//batch_size):
batch = mnist.train.next_batch(batch_size)
feed = {inputs_: batch[0], targets_: batch[0]}
batch_cost, _ = sess.run([cost, opt], feed_dict=feed)
print("Epoch: {}/{}...".format(e+1, epochs),
"Training loss: {:.4f}".format(batch_cost))
Explanation: Here I'll write a bit of code to train the network. I'm not too interested in validation here, so I'll just monitor the training loss.
Calling mnist.train.next_batch(batch_size) will return a tuple of (images, labels). We're not concerned with the labels here, we just need the images. Otherwise this is pretty straightfoward training with TensorFlow. We initialize the variables with sess.run(tf.global_variables_initializer()). Then, run the optimizer and get the loss with batch_cost, _ = sess.run([cost, opt], feed_dict=feed).
End of explanation
fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(20,4))
in_imgs = mnist.test.images[:10]
reconstructed, compressed = sess.run([decoded, encoded], feed_dict={inputs_: in_imgs})
for images, row in zip([in_imgs, reconstructed], axes):
for img, ax in zip(images, row):
ax.imshow(img.reshape((28, 28)), cmap='Greys_r')
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
fig.tight_layout(pad=0.1)
sess.close()
Explanation: Checking out the results
Below I've plotted some of the test images along with their reconstructions. For the most part these look pretty good except for some blurriness in some parts.
End of explanation |
3,478 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Kaggle Competition
Project 1
Step1: Import dataset
Step2: Notice that 'sentiment' is binary
Step3: Type 'object' is a string for pandas. We shall later convert to number representation,maybe using typical bag-of-words or word2vec
Starting getting basic information of data
Step4: Now that we already have general idea of Data Set. We next clean, transform data to create useful features for machine learning
First Attempt Summary
Feature 'review'
Processing raw text
Transforming feature 'review'
Step5: Before we can transform text into number representation, we need to process raw text. Let's first remove HTML and puctuation
Step6: Now we start stemming and lemmatizing the text, but it is generally better to first create the pos tagger as we only want to lemmatize verb and noum
Step7: Stemming the text
Step8: Observing that the word 'going' has been stemmed with porter but not with lancaster, I'll choose porter for this task.
let's lemmatizing
Step9: text cleanning summary
Step10: Transforming feature 'review'
Step11: Extending bag-of-words with TF-IDF weights
We could extend the bag-of-words representation with tf-idf to reflect how important a word to a document in a corpus
tdf-idf can be applied with class TfidfVectorizer in sklearn
Step12: Dimensionality reduction
Using stop_words was one technique to reduce dimensionality. We can further reduce the dimensinality by using latent sematic analysis
In sklearn, we can apply class TruncatedSVD into tf-idf matrix
Step13: Training Naive Bayes
Sklearn provides several kinds of Naives classifiers
Step14: Fitting the training data
Step15: Predicting with Naive Bayes
Step16: Preparing for kaggle submission
Step17: Performance Evaluation
A variety of metrics exist to evaluate the performance for binary classifiers, i.e accuracy, precision, recall, F1 measure, ROC AUC score. We shall use ROC AUC score for this task as specified by competition site.
Splitting train data set
We first splitting the train data set for cross validation, let's choose 80% for split_train set and 20% for split test_set
Step18: Evaluating model using splitted data set
ROC curve illustrates the classifier's performance for all values of the discrimination threshold.
Step19: Plotting ROC curve
ROC curves plot the classifier's recall against its fall-out.
Step20: The source code of the first attempt can be found here and evaluation script here
Hyperparameters
Class MultinomialNb has a parameter value alpha (default=1.0) We could try to run on another value of alpha to see how the score would change.
Step21: Let's try to generate score over a range of alpha | Python Code:
import pandas as pd
from bs4 import BeautifulSoup
import re
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics import roc_auc_score,roc_curve
from sklearn.decomposition import TruncatedSVD
from sklearn.cross_validation import train_test_split
from sklearn.naive_bayes import MultinomialNB
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import nltk
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
nltk.download('wordnet')
Explanation: Kaggle Competition
Project 1: Bag of Words Meets Bags of Popcorn
Author: Vu Tran
github
notebook
source
Project information:
Description
Evaluation
DataSet
Dataset visualization and pre-processing
Import packages
End of explanation
train_data=pd.read_csv("../../../data-project1/labeledTrainData.tsv", header=0, delimiter="\t", quoting=3)
train_data.head()
train_data.tail()
Explanation: Import dataset
End of explanation
train_data.dtypes
Explanation: Notice that 'sentiment' is binary
End of explanation
train_data.info()
Explanation: Type 'object' is a string for pandas. We shall later convert to number representation,maybe using typical bag-of-words or word2vec
Starting getting basic information of data:
End of explanation
train_data.review[0]
Explanation: Now that we already have general idea of Data Set. We next clean, transform data to create useful features for machine learning
First Attempt Summary
Feature 'review'
Processing raw text
Transforming feature 'review': bag-of-words model
Extending bag-of-words with TF-IDF weights
Dimensionality reduction
Training Naive Bayes
Predicting with Naive Bayes
Preparing for kaggle submission
Performance Evaluation
Splitting train data set
Evaluating performance using splitted data set
Plotting ROC curve
Hyperparameters
Other improvements
Feature 'review'
Processing raw text
We will start wrting function for analyzing and cleaning the deature 'review', using first review as a point of illustration
End of explanation
soup=BeautifulSoup(train_data.review[0]).get_text()
letters_only = re.sub("[^a-zA-Z]"," ",soup )
letters_only
Explanation: Before we can transform text into number representation, we need to process raw text. Let's first remove HTML and puctuation
End of explanation
tokens=nltk.word_tokenize(letters_only.lower())
tagged_words=nltk.pos_tag(tokens)
tagged_words[0:5]
Explanation: Now we start stemming and lemmatizing the text, but it is generally better to first create the pos tagger as we only want to lemmatize verb and noum
End of explanation
porter=nltk.PorterStemmer()
def lemmatize_with_potter(token,tag):
if tag[0].lower in ['v','n']:
return porter.stem(token)
return token
stemmed_text_with_potter=[lemmatize_with_potter(token,tag) for token,tag in tagged_words]
lancaster=nltk.LancasterStemmer()
def lemmatize_with_lancaster(token,tag):
if tag[0].lower in ['v','n']:
return lancaster.stem(token)
return token
stemmed_text_with_lancaster=[lemmatize_with_lancaster(token,tag) for token,tag in tagged_words]
stemmed_text_with_potter[0:10]
stemmed_text_with_lancaster[0:10]
Explanation: Stemming the text: There are genrally 2 stemmers available in nltk, porter and lancaster
End of explanation
tagged_words_after_stem=nltk.pos_tag(stemmed_text_with_potter)
wnl = nltk.WordNetLemmatizer()
def lemmatize_with_WordNet(token,tag):
if tag[0].lower in ['v','n']:
return wnl.lemmatize(token)
return token
stemmed_and_lemmatized_text=[lemmatize_with_WordNet(token,tag) for token,tag in tagged_words_after_stem]
stemmed_and_lemmatized_text[0:10]
Explanation: Observing that the word 'going' has been stemmed with porter but not with lancaster, I'll choose porter for this task.
let's lemmatizing
End of explanation
porter=nltk.PorterStemmer()
wnl = nltk.WordNetLemmatizer()
def stemmatize_with_potter(token,tag):
if tag[0].lower() in ['v','n']:
return porter.stem(token)
return token
def lemmatize_with_WordNet(token,tag):
if tag[0].lower() in ['v','n']:
return wnl.lemmatize(token)
return token
def corpus_preprocessing(corpus):
preprocessed_corpus = []
for sentence in corpus:
#remove HTML and puctuation
soup=BeautifulSoup(sentence).get_text()
letters_only = re.sub("[^a-zA-Z]"," ",soup )
#Stemming
tokens=nltk.word_tokenize(letters_only.lower())
tagged_words=nltk.pos_tag(tokens)
stemmed_text_with_potter=[stemmatize_with_potter(token,tag) for token,tag in tagged_words]
#lemmatization
tagged_words_after_stem=nltk.pos_tag(stemmed_text_with_potter)
stemmed_and_lemmatized_text=[lemmatize_with_WordNet(token,tag) for token,tag in tagged_words_after_stem]
#join all the tokens
clean_review=" ".join(w for w in stemmed_and_lemmatized_text)
preprocessed_corpus.append(clean_review)
return preprocessed_corpus
Explanation: text cleanning summary
End of explanation
vectorizer=CountVectorizer(stop_words='english')
test_corpus=train_data.review[0:5]
test_corpus= corpus_preprocessing(test_corpus)
test_corpus=vectorizer.fit_transform(test_corpus)
print(test_corpus.todense())
Explanation: Transforming feature 'review': bag-of-words model
Let's transform feature 'review' into numerical representation to feed into machine learning. The common representation of text is the bag-of-words model
in Sklearn, we can use class CountVectorize to transform the data. We shall also use stop-words to reduce the dimension of feature space. Let's now first 5 data from train Dataset to be test_corpus
End of explanation
vectorizer= TfidfVectorizer(stop_words='english')
test_corpus=train_data.review[0:5]
test_corpus= corpus_preprocessing(test_corpus)
test_corpus=vectorizer.fit_transform(test_corpus)
print (test_corpus.todense())
Explanation: Extending bag-of-words with TF-IDF weights
We could extend the bag-of-words representation with tf-idf to reflect how important a word to a document in a corpus
tdf-idf can be applied with class TfidfVectorizer in sklearn
End of explanation
tsvd=TruncatedSVD(100)
tsvd.fit(test_corpus)
test_corpus=tsvd.transform(test_corpus)
test_corpus
Explanation: Dimensionality reduction
Using stop_words was one technique to reduce dimensionality. We can further reduce the dimensinality by using latent sematic analysis
In sklearn, we can apply class TruncatedSVD into tf-idf matrix
End of explanation
model=MultinomialNB()
Explanation: Training Naive Bayes
Sklearn provides several kinds of Naives classifiers: GaussianNB, MultinomialNB and BernoulliNB. We will choose MultinomialNB for this task
End of explanation
#features from train set
train_features=train_data.review
#pro-processing train features
train_features=corpus_preprocessing(train_features)
vectorizer= TfidfVectorizer(stop_words='english')
train_features=vectorizer.fit_transform(train_features)
tsvd=TruncatedSVD(100)
tsvd.fit(train_features)
train_features=tsvd.transform(train_features)
#target from train set
train_target=train_data.sentiment
#fitting the model
model.fit(train_features,train_target)
Explanation: Fitting the training data
End of explanation
#reading test data
test_data=train_data=pd.read_csv("../../../data-project1/testData.tsv", header=0,delimiter="\t", quoting=3)
#features from test data
test_features=test_data.review
#pre-processing test features
test_features=corpus_preprocessing(test_features)
test_features=vectorizer.transform(test_features)
test_features=tsvd.transform(test_features)
#predicting the sentiment for test set
prediction=model.predict(test_features)
Explanation: Predicting with Naive Bayes
End of explanation
#writing out submission file
pd.DataFrame( data={"id":test_data["id"], "sentiment":prediction} ).to_csv("../../../data-project1/first_attempt.csv", index=False, quoting=3 )
Explanation: Preparing for kaggle submission
End of explanation
# Split 80-20 train vs test data
split_train_features, split_test_features, split_train_target, split_test_target = train_test_split(train_features,
train_target,
test_size = 0.20,
random_state = 0)
Explanation: Performance Evaluation
A variety of metrics exist to evaluate the performance for binary classifiers, i.e accuracy, precision, recall, F1 measure, ROC AUC score. We shall use ROC AUC score for this task as specified by competition site.
Splitting train data set
We first splitting the train data set for cross validation, let's choose 80% for split_train set and 20% for split test_set
End of explanation
#pre-processing split train
vectorizer= TfidfVectorizer(stop_words='english')
split_train_features = corpus_preprocessing(split_train_features)
split_train_features = vectorizer.fit_transform(split_train_features)
tsvd=TruncatedSVD(100)
tsvd.fit(split_train_features)
split_train_features = tsvd.transform(split_train_features)
#pre-processing split test features
split_test_features = corpus_preprocessing(split_test_features)
split_test_features = vectorizer.transform(split_test_features)
split_test_features = tsvd.transform(split_test_features)
#fit and predict using split data
model = MultinomialNB()
model.fit(split_train_features,split_train_target)
split_prediction = model.predict(split_test_features)
score=roc_auc_score(split_test_target, split_prediction)
print (score(split_test_target, split_prediction))
Explanation: Evaluating model using splitted data set
ROC curve illustrates the classifier's performance for all values of the discrimination threshold.
End of explanation
false_positive_rates ,recall,thresholds=roc_curve(split_test_target,split_prediction)
plt.title('Receiver Operating Charisteristic')
plt.plot(false_positive_rates,recall,'r', label='AUC = %0.2f' %score)
plt.legend(loc = 'lower right')
plt.ylable('Recall')
plt.xlable('False positive rate')
plt.show()
Explanation: Plotting ROC curve
ROC curves plot the classifier's recall against its fall-out.
End of explanation
model=MultinomialNB(alpha=0.1)
model.fit(split_train_features,split_train_target)
split_prediction=model.predict(split_test_features)
score=roc_auc_score(split_test_target, split_predict)
print (score(split_test_target, split_predict))
Explanation: The source code of the first attempt can be found here and evaluation script here
Hyperparameters
Class MultinomialNb has a parameter value alpha (default=1.0) We could try to run on another value of alpha to see how the score would change.
End of explanation
alphas=np.logspace(-5,0,6)
print alphas
def evaluate_alpha(train_features,train_target,test_features,test_target,model,parameter_value, parameter_name):
scores=[]
for test_alpha in params:
model. set_params(**{parameter_name:test_alpha})
model.fit(train_features,train_target)
prediction=model.predict(test_features)
score=roc_auc_score(test_target, prediction)
scores.append((test_alpha,score))
model=MultinomialNB()
alpha_score=evaluate_alpha(split_train_features,split_train_target,split_test_features,split_test_target,model,alphas,'alpha')
Explanation: Let's try to generate score over a range of alpha
End of explanation |
3,479 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Compute ICA on MEG data and remove artifacts
ICA is fit to MEG raw data.
The sources matching the ECG and EOG are automatically found and displayed.
Subsequently, artifact detection and rejection quality are assessed.
Step1: Setup paths and prepare raw data.
Step2: 1) Fit ICA model using the FastICA algorithm.
Step3: 2) identify bad components by analyzing latent sources.
Step4: 3) Assess component selection and unmixing quality. | Python Code:
# Authors: Denis Engemann <[email protected]>
# Alexandre Gramfort <[email protected]>
#
# License: BSD (3-clause)
import numpy as np
import mne
from mne.preprocessing import ICA
from mne.preprocessing import create_ecg_epochs, create_eog_epochs
from mne.datasets import sample
Explanation: Compute ICA on MEG data and remove artifacts
ICA is fit to MEG raw data.
The sources matching the ECG and EOG are automatically found and displayed.
Subsequently, artifact detection and rejection quality are assessed.
End of explanation
data_path = sample.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
raw = mne.io.read_raw_fif(raw_fname, preload=True)
raw.filter(1, 45, n_jobs=1, l_trans_bandwidth=0.5, h_trans_bandwidth=0.5,
filter_length='10s', phase='zero-double')
raw.annotations = mne.Annotations([1], [10], 'BAD')
raw.plot(block=True)
# For the sake of example we annotate first 10 seconds of the recording as
# 'BAD'. This part of data is excluded from the ICA decomposition by default.
# To turn this behavior off, pass ``reject_by_annotation=False`` to
# :meth:`mne.preprocessing.ICA.fit`.
raw.annotations = mne.Annotations([0], [10], 'BAD')
Explanation: Setup paths and prepare raw data.
End of explanation
# Other available choices are `infomax` or `extended-infomax`
# We pass a float value between 0 and 1 to select n_components based on the
# percentage of variance explained by the PCA components.
ica = ICA(n_components=0.95, method='fastica')
picks = mne.pick_types(raw.info, meg=True, eeg=False, eog=False,
stim=False, exclude='bads')
ica.fit(raw, picks=picks, decim=3, reject=dict(mag=4e-12, grad=4000e-13))
# maximum number of components to reject
n_max_ecg, n_max_eog = 3, 1 # here we don't expect horizontal EOG components
Explanation: 1) Fit ICA model using the FastICA algorithm.
End of explanation
title = 'Sources related to %s artifacts (red)'
# generate ECG epochs use detection via phase statistics
ecg_epochs = create_ecg_epochs(raw, tmin=-.5, tmax=.5, picks=picks)
ecg_inds, scores = ica.find_bads_ecg(ecg_epochs, method='ctps')
ica.plot_scores(scores, exclude=ecg_inds, title=title % 'ecg', labels='ecg')
show_picks = np.abs(scores).argsort()[::-1][:5]
ica.plot_sources(raw, show_picks, exclude=ecg_inds, title=title % 'ecg')
ica.plot_components(ecg_inds, title=title % 'ecg', colorbar=True)
ecg_inds = ecg_inds[:n_max_ecg]
ica.exclude += ecg_inds
# detect EOG by correlation
eog_inds, scores = ica.find_bads_eog(raw)
ica.plot_scores(scores, exclude=eog_inds, title=title % 'eog', labels='eog')
show_picks = np.abs(scores).argsort()[::-1][:5]
ica.plot_sources(raw, show_picks, exclude=eog_inds, title=title % 'eog')
ica.plot_components(eog_inds, title=title % 'eog', colorbar=True)
eog_inds = eog_inds[:n_max_eog]
ica.exclude += eog_inds
Explanation: 2) identify bad components by analyzing latent sources.
End of explanation
# estimate average artifact
ecg_evoked = ecg_epochs.average()
ica.plot_sources(ecg_evoked, exclude=ecg_inds) # plot ECG sources + selection
ica.plot_overlay(ecg_evoked, exclude=ecg_inds) # plot ECG cleaning
eog_evoked = create_eog_epochs(raw, tmin=-.5, tmax=.5, picks=picks).average()
ica.plot_sources(eog_evoked, exclude=eog_inds) # plot EOG sources + selection
ica.plot_overlay(eog_evoked, exclude=eog_inds) # plot EOG cleaning
# check the amplitudes do not change
ica.plot_overlay(raw) # EOG artifacts remain
# To save an ICA solution you can say:
# ica.save('my_ica.fif')
# You can later load the solution by saying:
# from mne.preprocessing import read_ica
# read_ica('my_ica.fif')
# Apply the solution to Raw, Epochs or Evoked like this:
# ica.apply(epochs)
Explanation: 3) Assess component selection and unmixing quality.
End of explanation |
3,480 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<a href="https
Step1: Some things to notice
Step2: Both are reasonably linear, but neither is a perfect fit!
Fit both models with MLE
At this point, our best bet is to find parameter sets for both models that provide best fit to observed data $y$. We will use maximum likelihood estimation.
Step 1 -- compute the likelihood function
First, let's cast our data as the number of items recalled correctly on $n=100$ trials.
Step3: Let's assume each of these 100 trials is independent of the others, and consider each trial a success if item is correctly recalled.
Then the probability of correctly recalling $x$ items is | Python Code:
import matplotlib.pyplot as plt
import numpy as np
T = np.array([1, 3, 6, 9, 12, 18])
Y = np.array([0.94, 0.77, 0.40, 0.26, 0.24, 0.16])
plt.plot(T, Y, 'o')
plt.xlabel('Retention interval (sec.)')
plt.ylabel('Proportion recalled')
plt.show()
Explanation: <a href="https://colab.research.google.com/github/tomfaulkenberry/courses/blob/master/spring2019/mathpsychREU/lecture2.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
Lecture 2 - Fitting a "forgetting curve"
It is well-known that once we learn something, we tend forget some things as time passes.
Murdock (1961) presented subjects with a set of memory items (i.e., words or letters) and asked them to recall the items after six different retention intervals: $t=1,3,6,9,12,18$ (in seconds). He recorded the proportion recalled at each retention interval (based on 100 independent trials for each $t$). These data were (respectively)
$$
y=0.94, 0.77, 0.40, 0.26, 0.24, 0.16
$$
Our goal: fit a mathematical model that will predict the proportion recalled $y$ as a function of retention interval ($t$)
First step - look at the data!
End of explanation
# check power function model
plt.plot(np.log(T), np.log(Y), 'o')
plt.xlabel('$\ln t$')
plt.ylabel('$\ln y$')
plt.show()
# check exponential model
plt.plot(T, np.log(Y), 'o')
plt.xlabel('$t$')
plt.ylabel('$\ln y$')
plt.show()
Explanation: Some things to notice:
our model should be a decreasing function
it is NOT linear
Two candidate models:
Power function model: $y=ax^b$
Exponential model: $y=ab^x$
Which one should we use?
mathematical properties?
Take logs and look at structure of data
Power function model: $\ln y = \ln a + b\ln x$
* so power $\implies$ $\ln y$ should be linear wrt $\ln x$
Exponential model: $\ln y = \ln a + x\ln b$
* so exponential $\implies$ $\ln y$ should be linear wrt $x$
End of explanation
X = 100*Y
print(X)
Explanation: Both are reasonably linear, but neither is a perfect fit!
Fit both models with MLE
At this point, our best bet is to find parameter sets for both models that provide best fit to observed data $y$. We will use maximum likelihood estimation.
Step 1 -- compute the likelihood function
First, let's cast our data as the number of items recalled correctly on $n=100$ trials.
End of explanation
def nllP(pars):
a, b = pars
tmp1 = X*np.log(a*T**b)
tmp2 = (100-X)*np.log(1-a*T**b)
return(-1*np.sum(tmp1+tmp2))
# check some examples
a = 0.9
b = -0.4
pars = np.array([a,b])
nllP(pars)
from scipy.optimize import minimize
a_init = np.random.uniform()
b_init = -np.random.uniform()
inits = np.array([a_init, b_init])
mleP = minimize(nllP,
inits,
method="nelder-mead")
print(mleP)
def power(t,pars):
a, b = pars
return(a*t**b)
fitPars = mleP.x
print(f"a={fitPars[0]:.3f}, b={fitPars[1]:.3f}")
x = np.linspace(0.5,18,100)
plt.plot(T,Y,'o')
plt.plot(x, power(x,fitPars))
plt.show()
Explanation: Let's assume each of these 100 trials is independent of the others, and consider each trial a success if item is correctly recalled.
Then the probability of correctly recalling $x$ items is:
$$
f(x\mid\theta) = \binom{100}{x}\theta^x(1-\theta)^{100-x}
$$
The critical parameter here is $\theta$ -- the probability of success on any one trial. How do we determine $\theta$?
Let's assume that probability of recall is governed by a power function. That is, assume
$$
\theta(t) = at^b
$$
for constants $a,b$.
Then we can write
$$
f(x\mid a,b) = \binom{100}{x}(at^b)^x(1-at^b)^{100-x}
$$
which we cast as a likelihood
$$
L(a,b\mid x) = \binom{100}{x}(at^b)^x(1-at^b)^{100-x}
$$
Step 2 -- compute log likelihood
This gives us:
$$
\ln L = \ln \Biggl[ \binom{100}{x}\Biggr] + x\ln(at^b) + (100-x)\ln(1-at^b)
$$
Step 3 -- extend to multiple observations
Note that the formula above is for a single observation $x$. But we have 5 observations!
If we assume each is independent from the others, then we can multiply the likelihoods:
$$
L(a,b\mid x=(x_1,\dots,x_5)) = \prod_{i=1}^5 L(a,b\mid x_i)
$$
Thus we have
$$
\ln L = \ln\Biggl(\prod_{i=1}^5 L(a,b\mid x_i)\Biggr )
$$
But since logs turn products into sums, we can write
$$ \ln L = \sum_{i=1}^5 \ln L(a,b\mid x_i) = \sum_{i=1}^5 \Biggl(\ln \binom{100}{x_i} + x_i\ln(at^b) + (100-x_i)\ln(1-at^b)\Biggr)$$
Notes:
we really only care about the terms that have $a$ and $b$, so we'll ignore the binomial term
Python really likes to minimize. So, we will minimize the negative log likelihood (NLL)
End of explanation |
3,481 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Step1: Implementing a Neural Network
In this exercise we will develop a neural network with fully-connected layers to perform classification, and test it out on the CIFAR-10 dataset.
Step2: We will use the class TwoLayerNet in the file cs231n/classifiers/neural_net.py to represent instances of our network. The network parameters are stored in the instance variable self.params where keys are string parameter names and values are numpy arrays. Below, we initialize toy data and a toy model that we will use to develop your implementation.
Step3: Forward pass
Step4: Forward pass
Step5: Backward pass
Implement the rest of the function. This will compute the gradient of the loss with respect to the variables W1, b1, W2, and b2. Now that you (hopefully!) have a correctly implemented forward pass, you can debug your backward pass using a numeric gradient check
Step6: Train the network
To train the network we will use stochastic gradient descent (SGD), similar to the SVM and Softmax classifiers. Look at the function TwoLayerNet.train and fill in the missing sections to implement the training procedure. This should be very similar to the training procedure you used for the SVM and Softmax classifiers. You will also have to implement TwoLayerNet.predict, as the training process periodically performs prediction to keep track of accuracy over time while the network trains.
Once you have implemented the method, run the code below to train a two-layer network on toy data. You should achieve a training loss less than 0.2.
Step8: Load the data
Now that you have implemented a two-layer network that passes gradient checks and works on toy data, it's time to load up our favorite CIFAR-10 data so we can use it to train a classifier on a real dataset.
Step9: Train a network
To train our network we will use SGD with momentum. In addition, we will adjust the learning rate with an exponential learning rate schedule as optimization proceeds; after each epoch, we will reduce the learning rate by multiplying it by a decay rate.
Step10: Debug the training
With the default parameters we provided above, you should get a validation accuracy of about 0.29 on the validation set. This isn't very good.
One strategy for getting insight into what's wrong is to plot the loss function and the accuracies on the training and validation sets during optimization.
Another strategy is to visualize the weights that were learned in the first layer of the network. In most neural networks trained on visual data, the first layer weights typically show some visible structure when visualized.
Step11: Tune your hyperparameters
What's wrong?. Looking at the visualizations above, we see that the loss is decreasing more or less linearly, which seems to suggest that the learning rate may be too low. Moreover, there is no gap between the training and validation accuracy, suggesting that the model we used has low capacity, and that we should increase its size. On the other hand, with a very large model we would expect to see more overfitting, which would manifest itself as a very large gap between the training and validation accuracy.
Tuning. Tuning the hyperparameters and developing intuition for how they affect the final performance is a large part of using Neural Networks, so we want you to get a lot of practice. Below, you should experiment with different values of the various hyperparameters, including hidden layer size, learning rate, numer of training epochs, and regularization strength. You might also consider tuning the learning rate decay, but you should be able to get good performance using the default value.
Approximate results. You should be aim to achieve a classification accuracy of greater than 48% on the validation set. Our best network gets over 52% on the validation set.
Experiment
Step12: Run on the test set
When you are done experimenting, you should evaluate your final trained network on the test set; you should get above 48%.
We will give you extra bonus point for every 1% of accuracy above 52%. | Python Code:
# A bit of setup
import numpy as np
import matplotlib.pyplot as plt
from cs231n.classifiers.neural_net import TwoLayerNet
%matplotlib inline
plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# for auto-reloading external modules
# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython
%load_ext autoreload
%autoreload 2
def rel_error(x, y):
returns relative error
return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))
Explanation: Implementing a Neural Network
In this exercise we will develop a neural network with fully-connected layers to perform classification, and test it out on the CIFAR-10 dataset.
End of explanation
# Create a small net and some toy data to check your implementations.
# Note that we set the random seed for repeatable experiments.
input_size = 4
hidden_size = 10
num_classes = 3
num_inputs = 5
def init_toy_model():
np.random.seed(0)
return TwoLayerNet(input_size, hidden_size, num_classes, std=1e-1)
def init_toy_data():
np.random.seed(1)
X = 10 * np.random.randn(num_inputs, input_size)
y = np.array([0, 1, 2, 2, 1])
return X, y
net = init_toy_model()
X, y = init_toy_data()
Explanation: We will use the class TwoLayerNet in the file cs231n/classifiers/neural_net.py to represent instances of our network. The network parameters are stored in the instance variable self.params where keys are string parameter names and values are numpy arrays. Below, we initialize toy data and a toy model that we will use to develop your implementation.
End of explanation
scores = net.loss(X)
print 'Your scores:'
print scores
print
print 'correct scores:'
correct_scores = np.asarray([
[-0.81233741, -1.27654624, -0.70335995],
[-0.17129677, -1.18803311, -0.47310444],
[-0.51590475, -1.01354314, -0.8504215 ],
[-0.15419291, -0.48629638, -0.52901952],
[-0.00618733, -0.12435261, -0.15226949]])
print correct_scores
print
# The difference should be very small. We get < 1e-7
print 'Difference between your scores and correct scores:'
print np.sum(np.abs(scores - correct_scores))
Explanation: Forward pass: compute scores
Open the file cs231n/classifiers/neural_net.py and look at the method TwoLayerNet.loss. This function is very similar to the loss functions you have written for the SVM and Softmax exercises: It takes the data and weights and computes the class scores, the loss, and the gradients on the parameters.
Implement the first part of the forward pass which uses the weights and biases to compute the scores for all inputs.
End of explanation
loss, _ = net.loss(X, y, reg=0.1)
correct_loss = 1.30378789133
# should be very small, we get < 1e-12
print 'Difference between your loss and correct loss:'
print np.sum(np.abs(loss - correct_loss))
Explanation: Forward pass: compute loss
In the same function, implement the second part that computes the data and regularizaion loss.
End of explanation
from cs231n.gradient_check import eval_numerical_gradient
# Use numeric gradient checking to check your implementation of the backward pass.
# If your implementation is correct, the difference between the numeric and
# analytic gradients should be less than 1e-8 for each of W1, W2, b1, and b2.
loss, grads = net.loss(X, y, reg=0.1)
# these should all be less than 1e-8 or so
for param_name in grads:
f = lambda W: net.loss(X, y, reg=0.1)[0]
param_grad_num = eval_numerical_gradient(f, net.params[param_name], verbose=False)
print '%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name]))
Explanation: Backward pass
Implement the rest of the function. This will compute the gradient of the loss with respect to the variables W1, b1, W2, and b2. Now that you (hopefully!) have a correctly implemented forward pass, you can debug your backward pass using a numeric gradient check:
End of explanation
net = init_toy_model()
stats = net.train(X, y, X, y,
learning_rate=1e-1, reg=1e-5,
num_iters=100, verbose=False)
print 'Final training loss: ', stats['loss_history'][-1]
# plot the loss history
plt.plot(stats['loss_history'])
plt.xlabel('iteration')
plt.ylabel('training loss')
plt.title('Training Loss history')
plt.show()
Explanation: Train the network
To train the network we will use stochastic gradient descent (SGD), similar to the SVM and Softmax classifiers. Look at the function TwoLayerNet.train and fill in the missing sections to implement the training procedure. This should be very similar to the training procedure you used for the SVM and Softmax classifiers. You will also have to implement TwoLayerNet.predict, as the training process periodically performs prediction to keep track of accuracy over time while the network trains.
Once you have implemented the method, run the code below to train a two-layer network on toy data. You should achieve a training loss less than 0.2.
End of explanation
from cs231n.data_utils import load_CIFAR10
def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):
Load the CIFAR-10 dataset from disk and perform preprocessing to prepare
it for the two-layer neural net classifier. These are the same steps as
we used for the SVM, but condensed to a single function.
# Load the raw CIFAR-10 data
cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'
X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)
# Subsample the data
mask = range(num_training, num_training + num_validation)
X_val = X_train[mask]
y_val = y_train[mask]
mask = range(num_training)
X_train = X_train[mask]
y_train = y_train[mask]
mask = range(num_test)
X_test = X_test[mask]
y_test = y_test[mask]
# Normalize the data: subtract the mean image
mean_image = np.mean(X_train, axis=0)
X_train -= mean_image
X_val -= mean_image
X_test -= mean_image
# Reshape data to rows
X_train = X_train.reshape(num_training, -1)
X_val = X_val.reshape(num_validation, -1)
X_test = X_test.reshape(num_test, -1)
return X_train, y_train, X_val, y_val, X_test, y_test
# Invoke the above function to get our data.
X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()
print 'Train data shape: ', X_train.shape
print 'Train labels shape: ', y_train.shape
print 'Validation data shape: ', X_val.shape
print 'Validation labels shape: ', y_val.shape
print 'Test data shape: ', X_test.shape
print 'Test labels shape: ', y_test.shape
Explanation: Load the data
Now that you have implemented a two-layer network that passes gradient checks and works on toy data, it's time to load up our favorite CIFAR-10 data so we can use it to train a classifier on a real dataset.
End of explanation
input_size = 32 * 32 * 3
hidden_size = 50
num_classes = 10
net = TwoLayerNet(input_size, hidden_size, num_classes)
# Train the network
stats = net.train(X_train, y_train, X_val, y_val,
num_iters=1000, batch_size=200,
learning_rate=1e-4, learning_rate_decay=0.95,
reg=0.5, verbose=True)
# Predict on the validation set
val_acc = (net.predict(X_val) == y_val).mean()
print 'Validation accuracy: ', val_acc
Explanation: Train a network
To train our network we will use SGD with momentum. In addition, we will adjust the learning rate with an exponential learning rate schedule as optimization proceeds; after each epoch, we will reduce the learning rate by multiplying it by a decay rate.
End of explanation
# Plot the loss function and train / validation accuracies
plt.subplot(2, 1, 1)
plt.plot(stats['loss_history'])
plt.title('Loss history')
plt.xlabel('Iteration')
plt.ylabel('Loss')
plt.subplot(2, 1, 2)
plt.plot(stats['train_acc_history'], label='train')
plt.plot(stats['val_acc_history'], label='val')
plt.title('Classification accuracy history')
plt.xlabel('Epoch')
plt.ylabel('Clasification accuracy')
plt.show()
from cs231n.vis_utils import visualize_grid
# Visualize the weights of the network
def show_net_weights(net):
W1 = net.params['W1']
W1 = W1.reshape(32, 32, 3, -1).transpose(3, 0, 1, 2)
plt.imshow(visualize_grid(W1, padding=3).astype('uint8'))
plt.gca().axis('off')
plt.show()
show_net_weights(net)
Explanation: Debug the training
With the default parameters we provided above, you should get a validation accuracy of about 0.29 on the validation set. This isn't very good.
One strategy for getting insight into what's wrong is to plot the loss function and the accuracies on the training and validation sets during optimization.
Another strategy is to visualize the weights that were learned in the first layer of the network. In most neural networks trained on visual data, the first layer weights typically show some visible structure when visualized.
End of explanation
best_net = None # store the best model into this
#################################################################################
# TODO: Tune hyperparameters using the validation set. Store your best trained #
# model in best_net. #
# #
# To help debug your network, it may help to use visualizations similar to the #
# ones we used above; these visualizations will have significant qualitative #
# differences from the ones we saw above for the poorly tuned network. #
# #
# Tweaking hyperparameters by hand can be fun, but you might find it useful to #
# write code to sweep through possible combinations of hyperparameters #
# automatically like we did on the previous exercises. #
#################################################################################
best_val = -1
best_stats = None
learning_rates = [1e-2, 1e-3]
regularization_strengths = [0.4, 0.5, 0.6]
results = {}
iters = 2000 #100
for lr in learning_rates:
for rs in regularization_strengths:
net = TwoLayerNet(input_size, hidden_size, num_classes)
# Train the network
stats = net.train(X_train, y_train, X_val, y_val,
num_iters=iters, batch_size=200,
learning_rate=lr, learning_rate_decay=0.95,
reg=rs)
y_train_pred = net.predict(X_train)
acc_train = np.mean(y_train == y_train_pred)
y_val_pred = net.predict(X_val)
acc_val = np.mean(y_val == y_val_pred)
results[(lr, rs)] = (acc_train, acc_val)
if best_val < acc_val:
best_stats = stats
best_val = acc_val
best_net = net
# Print out results.
for lr, reg in sorted(results):
train_accuracy, val_accuracy = results[(lr, reg)]
print 'lr %e reg %e train accuracy: %f val accuracy: %f' % (
lr, reg, train_accuracy, val_accuracy)
print 'best validation accuracy achieved during cross-validation: %f' % best_val
#################################################################################
# END OF YOUR CODE #
#################################################################################
# visualize the weights of the best network
show_net_weights(best_net)
# Plot the loss function and train / validation accuracies
plt.subplot(2, 1, 1)
plt.plot(best_stats['loss_history'])
plt.title('Loss history')
plt.xlabel('Iteration')
plt.ylabel('Loss')
plt.subplot(2, 1, 2)
plt.plot(best_stats['train_acc_history'], label='train')
plt.plot(best_stats['val_acc_history'], label='val')
plt.title('Classification accuracy history')
plt.xlabel('Epoch')
plt.ylabel('Clasification accuracy')
plt.show()
Explanation: Tune your hyperparameters
What's wrong?. Looking at the visualizations above, we see that the loss is decreasing more or less linearly, which seems to suggest that the learning rate may be too low. Moreover, there is no gap between the training and validation accuracy, suggesting that the model we used has low capacity, and that we should increase its size. On the other hand, with a very large model we would expect to see more overfitting, which would manifest itself as a very large gap between the training and validation accuracy.
Tuning. Tuning the hyperparameters and developing intuition for how they affect the final performance is a large part of using Neural Networks, so we want you to get a lot of practice. Below, you should experiment with different values of the various hyperparameters, including hidden layer size, learning rate, numer of training epochs, and regularization strength. You might also consider tuning the learning rate decay, but you should be able to get good performance using the default value.
Approximate results. You should be aim to achieve a classification accuracy of greater than 48% on the validation set. Our best network gets over 52% on the validation set.
Experiment: You goal in this exercise is to get as good of a result on CIFAR-10 as you can, with a fully-connected Neural Network. For every 1% above 52% on the Test set we will award you with one extra bonus point. Feel free implement your own techniques (e.g. PCA to reduce dimensionality, or adding dropout, or adding features to the solver, etc.).
End of explanation
test_acc = (best_net.predict(X_test) == y_test).mean()
print 'Test accuracy: ', test_acc
Explanation: Run on the test set
When you are done experimenting, you should evaluate your final trained network on the test set; you should get above 48%.
We will give you extra bonus point for every 1% of accuracy above 52%.
End of explanation |
3,482 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Auto-correlative Functions and Correlograms
When working with time series data, there are a number of important diagnostics one should consider to help understand more about the data. The auto-correlative function, plotted as a correlogram, helps explain how a given observations relates to recent preceding observations. A very random process (like lottery numbers) would show very low values, while temperature (our topic in this episode) does correlate highly with recent days. <br><br> <!-- audio player -->
Step1: Below is a time series of the weather in Chapel Hill, NC every morning over a few years. You can clearly see an annual cyclic pattern, which should be no suprise to anyone. Yet, you can also see a fair amount of variance from day to day. Even if you de-trend the annual cycle, we can see that this would not be enough for yesterday's temperature to perfectly predict today's weather.
Step2: Below is a correlogram of the ACF (auto-correlative function). For very low values of lag (comparing the most recent temperature measurement to the values of previous days), we can see a quick drop-off. This tells us that weather correlates very highly, but decliningly so, with recent days.
Interestingly, we also see it negatively correlate with days far away. This is because of the "opposite" seasons we experience. The annual cycle of the planet is visible as we see weaker correlations with previous years.
This highlights one limit to the ACF. If compares the current weather to all previous days and reports those correlations independently. If we know today and yesterday's weather, the weather from two days ago might not add as much information.
Step3: For that reason, we also want to review the PACF (partial auto-correlative function) which subtracts the correlation of previous days for each lag so that we get an estimate of what each of those days actually contributes to the most recent observation. In the plots below of the same data, we see all the seasonal and annual correlations disappear. We expect this because most of the information about how the weather depends on the past is already contained in the most recent few days.
Step4: The boundaries shown in the above plots represent a measure of statistical significant. Any points outside this rang are considered statistically significant. Those below it are not.
As many listeners know, Kyle and Linh Da are looking to buy a house. In fact, they've made an offer on a house in the zipcode 90008. Thanks to the Trulia API, we can get a time series of the average median listing price of homes in that zipcode and see if it gives us any insight into the viability of this investment's future!
Step5: The plot below shows the time series of the median listing price (note, that's not the same as the sale price) on a daily basis over the past few years.
Step6: Let's first take a look at it's ACF below. For price, we see (no surprise) that recent listing prices are pretty good predictors of current listing prices. Unless some catastrophe or major event (like discovery of oil or a large gold vein) changed things overnight, home prices should have relatively stable short term prices, and therefore, be very auto-correlative.
Step7: As we did previously, we now want to look at the PACF (below) which shows us that the two most recent days have the most useful information. Although not surprising, I was wondering if we might find some interesting effects related to houses being listed on weekdays vs. weekends, or at specific times of the month. However, it seems that when dealing with such large amounts of money, people have a bit more patience. Perhaps selling a car or a smaller item might show some periodic lags, but the home prices do not. | Python Code:
%matplotlib inline
import matplotlib as mpl
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from datetime import datetime
import trulia.stats
import geocoder
import json
from datetime import timedelta
from collections import defaultdict
import time
import requests
from statsmodels.graphics import tsaplots
import ConfigParser as cp
cparser = cp.ConfigParser()
cparser.readfp(open('config.properties'))
api_key = cparser.get('weather', 'api_key')
cache = defaultdict(str)
g = geocoder.google('Chapel Hill, NC')
sd = '2010-01-01'
ed = '2016-04-16'
sd2 = pd.to_datetime(sd).to_datetime()
ed2 = pd.to_datetime(ed).to_datetime()
# This is long running, so I like to cache it, walk away, and come back to my nice dataset
x = sd2 + timedelta(hours=9)
while x < datetime.now():
url = 'https://api.forecast.io/forecast/{}/{},{},{}'.format(api_key, g.lat, g.lng, x.strftime("%Y-%m-%dT%H:%M:%S"))
if cache[url] == '':
r2 = requests.get(url)
time.sleep(.2)
resp = json.loads(r2.content)
cache[url] = resp
x = x + timedelta(days=1)
times = []
temps = []
x = sd2 + timedelta(hours=9)
while x < datetime.now():
url = 'https://api.forecast.io/forecast/{}/{},{},{}'.format(api_key, g.lat, g.lng, x.strftime("%Y-%m-%dT%H:%M:%S"))
resp = cache[url]
times.append(x)
temps.append(resp['currently']['temperature'])
x = x + timedelta(days=1)
df2 = pd.DataFrame({'time': times, 'temp': temps})
df2.set_index('time', inplace=True)
Explanation: Auto-correlative Functions and Correlograms
When working with time series data, there are a number of important diagnostics one should consider to help understand more about the data. The auto-correlative function, plotted as a correlogram, helps explain how a given observations relates to recent preceding observations. A very random process (like lottery numbers) would show very low values, while temperature (our topic in this episode) does correlate highly with recent days. <br><br> <!-- audio player -->
End of explanation
plt.figure(figsize=(15,5))
plt.plot(df2)
plt.title('Chapel Hill, NC weather')
plt.show()
Explanation: Below is a time series of the weather in Chapel Hill, NC every morning over a few years. You can clearly see an annual cyclic pattern, which should be no suprise to anyone. Yet, you can also see a fair amount of variance from day to day. Even if you de-trend the annual cycle, we can see that this would not be enough for yesterday's temperature to perfectly predict today's weather.
End of explanation
fig = tsaplots.plot_acf(df2[0:700], ax=None)
fig.set_figwidth(20)
fig.set_figheight(5)
Explanation: Below is a correlogram of the ACF (auto-correlative function). For very low values of lag (comparing the most recent temperature measurement to the values of previous days), we can see a quick drop-off. This tells us that weather correlates very highly, but decliningly so, with recent days.
Interestingly, we also see it negatively correlate with days far away. This is because of the "opposite" seasons we experience. The annual cycle of the planet is visible as we see weaker correlations with previous years.
This highlights one limit to the ACF. If compares the current weather to all previous days and reports those correlations independently. If we know today and yesterday's weather, the weather from two days ago might not add as much information.
End of explanation
fig = tsaplots.plot_pacf(df2[0:400], ax=None)
fig.set_figwidth(20)
fig.set_figheight(5)
Explanation: For that reason, we also want to review the PACF (partial auto-correlative function) which subtracts the correlation of previous days for each lag so that we get an estimate of what each of those days actually contributes to the most recent observation. In the plots below of the same data, we see all the seasonal and annual correlations disappear. We expect this because most of the information about how the weather depends on the past is already contained in the most recent few days.
End of explanation
cparser = cp.ConfigParser()
cparser.readfp(open('config.properties'))
tkey = cparser.get('trulia', 'key')
zc = '90008'
data = trulia.stats.TruliaStats(tkey).get_zip_code_stats(zip_code=zc, start_date=sd, end_date=ed)
weeks = []
medians = []
for week in data['listingStats']['listingStat']:
weeks.append(week['weekEndingDate'])
medians.append(week['listingPrice']['subcategory'][0]['medianListingPrice'])
df = pd.DataFrame({'week': weeks, 'medianPrice': medians})
df['week'] = pd.to_datetime(df['week'])
df['medianPrice'] = df['medianPrice'].astype(float)
df.sort('week', inplace=True)
df.set_index('week', inplace=True)
Explanation: The boundaries shown in the above plots represent a measure of statistical significant. Any points outside this rang are considered statistically significant. Those below it are not.
As many listeners know, Kyle and Linh Da are looking to buy a house. In fact, they've made an offer on a house in the zipcode 90008. Thanks to the Trulia API, we can get a time series of the average median listing price of homes in that zipcode and see if it gives us any insight into the viability of this investment's future!
End of explanation
plt.figure(figsize=(15,5))
plt.plot(df)
plt.ylabel('Median Listing Price')
plt.gca().get_yaxis().set_major_formatter(mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))
plt.show()
Explanation: The plot below shows the time series of the median listing price (note, that's not the same as the sale price) on a daily basis over the past few years.
End of explanation
fig = tsaplots.plot_acf(df, ax=None)
fig.set_figwidth(20)
fig.set_figheight(5)
Explanation: Let's first take a look at it's ACF below. For price, we see (no surprise) that recent listing prices are pretty good predictors of current listing prices. Unless some catastrophe or major event (like discovery of oil or a large gold vein) changed things overnight, home prices should have relatively stable short term prices, and therefore, be very auto-correlative.
End of explanation
fig = tsaplots.plot_pacf(df, ax=None)
fig.set_figwidth(20)
fig.set_figheight(5)
Explanation: As we did previously, we now want to look at the PACF (below) which shows us that the two most recent days have the most useful information. Although not surprising, I was wondering if we might find some interesting effects related to houses being listed on weekdays vs. weekends, or at specific times of the month. However, it seems that when dealing with such large amounts of money, people have a bit more patience. Perhaps selling a car or a smaller item might show some periodic lags, but the home prices do not.
End of explanation |
3,483 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Isentropic Analysis
The MetPy function mcalc.isentropic_interpolation allows for isentropic analysis from model
analysis data in isobaric coordinates.
Step1: Getting the data
In this example, NARR reanalysis data for 18 UTC 04 April 1987 from the National Centers
for Environmental Information (https
Step2: We will reduce the dimensionality of the data as it is pulled in to remove an empty time
dimension. Additionally, units are required for input data, so the proper units will also
be attached.
Step3: To properly interpolate to isentropic coordinates, the function must know the desired output
isentropic levels. An array with these levels will be created below.
Step4: Conversion to Isentropic Coordinates
Once three dimensional data in isobaric coordinates has been pulled and the desired
isentropic levels created, the conversion to isentropic coordinates can begin. Data will be
passed to the function as below. The function requires that isentropic levels, isobaric
levels, and temperature be input. Any additional inputs (in this case relative humidity, u,
and v wind components) will be linearly interpolated to isentropic space.
Step5: The output is a list, so now we will separate the variables to different names before
plotting.
Step6: A quick look at the shape of these variables will show that the data is now in isentropic
coordinates, with the number of vertical levels as specified above.
Step7: Converting to Relative Humidity
The NARR only gives specific humidity on isobaric vertical levels, so relative humidity will
have to be calculated after the interpolation to isentropic space.
Step8: Plotting the Isentropic Analysis
Step9: Montgomery Streamfunction
The Montgomery Streamfunction, ${\psi} = gdz + CpT$, is often desired because its
gradient is proportional to the geostrophic wind in isentropic space. This can be easily
calculated with mcalc.montgomery_streamfunction. | Python Code:
import cartopy.crs as ccrs
import cartopy.feature as cfeature
import matplotlib.pyplot as plt
from netCDF4 import Dataset, num2date
import numpy as np
import metpy.calc as mcalc
from metpy.cbook import get_test_data
from metpy.plots import add_metpy_logo
from metpy.units import units
Explanation: Isentropic Analysis
The MetPy function mcalc.isentropic_interpolation allows for isentropic analysis from model
analysis data in isobaric coordinates.
End of explanation
data = Dataset(get_test_data('narr_example.nc', False))
print(list(data.variables))
Explanation: Getting the data
In this example, NARR reanalysis data for 18 UTC 04 April 1987 from the National Centers
for Environmental Information (https://www.ncdc.noaa.gov/data-access/model-data)
will be used.
End of explanation
# Assign data to variable names
dtime = data.variables['Geopotential_height'].dimensions[0]
dlev = data.variables['Geopotential_height'].dimensions[1]
lat = data.variables['lat'][:]
lon = data.variables['lon'][:]
lev = data.variables[dlev][:] * units(data.variables[dlev].units)
times = data.variables[dtime]
vtimes = num2date(times[:], times.units)
temps = data.variables['Temperature']
tmp = temps[0, :] * units.kelvin
uwnd = data.variables['u_wind'][0, :] * units(data.variables['u_wind'].units)
vwnd = data.variables['v_wind'][0, :] * units(data.variables['v_wind'].units)
hgt = data.variables['Geopotential_height'][0, :] * units.meter
spech = (data.variables['Specific_humidity'][0, :] *
units(data.variables['Specific_humidity'].units))
Explanation: We will reduce the dimensionality of the data as it is pulled in to remove an empty time
dimension. Additionally, units are required for input data, so the proper units will also
be attached.
End of explanation
isentlevs = [296.] * units.kelvin
Explanation: To properly interpolate to isentropic coordinates, the function must know the desired output
isentropic levels. An array with these levels will be created below.
End of explanation
isent_anal = mcalc.isentropic_interpolation(isentlevs,
lev,
tmp,
spech,
uwnd,
vwnd,
hgt,
tmpk_out=True)
Explanation: Conversion to Isentropic Coordinates
Once three dimensional data in isobaric coordinates has been pulled and the desired
isentropic levels created, the conversion to isentropic coordinates can begin. Data will be
passed to the function as below. The function requires that isentropic levels, isobaric
levels, and temperature be input. Any additional inputs (in this case relative humidity, u,
and v wind components) will be linearly interpolated to isentropic space.
End of explanation
isentprs = isent_anal[0]
isenttmp = isent_anal[1]
isentspech = isent_anal[2]
isentu = isent_anal[3].to('kt')
isentv = isent_anal[4].to('kt')
isenthgt = isent_anal[5]
Explanation: The output is a list, so now we will separate the variables to different names before
plotting.
End of explanation
print(isentprs.shape)
print(isentspech.shape)
print(isentu.shape)
print(isentv.shape)
print(isenttmp.shape)
print(isenthgt.shape)
Explanation: A quick look at the shape of these variables will show that the data is now in isentropic
coordinates, with the number of vertical levels as specified above.
End of explanation
isentrh = mcalc.relative_humidity_from_specific_humidity(isentspech, isenttmp, isentprs)
Explanation: Converting to Relative Humidity
The NARR only gives specific humidity on isobaric vertical levels, so relative humidity will
have to be calculated after the interpolation to isentropic space.
End of explanation
# Set up our projection
crs = ccrs.LambertConformal(central_longitude=-100.0, central_latitude=45.0)
# Set up our array of latitude and longitude values and transform to
# the desired projection.
tlatlons = crs.transform_points(ccrs.PlateCarree(), lon, lat)
tlons = tlatlons[:, :, 0]
tlats = tlatlons[:, :, 1]
# Coordinates to limit map area
bounds = [(-122., -75., 25., 50.)]
# Choose a level to plot, in this case 296 K
level = 0
# Get data to plot state and province boundaries
states_provinces = cfeature.NaturalEarthFeature(category='cultural',
name='admin_1_states_provinces_lakes',
scale='50m',
facecolor='none')
fig = plt.figure(1, figsize=(17., 12.))
add_metpy_logo(fig, 120, 245, size='large')
ax = fig.add_subplot(1, 1, 1, projection=crs)
ax.set_extent(*bounds, crs=ccrs.PlateCarree())
ax.coastlines('50m', edgecolor='black', linewidth=0.75)
ax.add_feature(states_provinces, edgecolor='black', linewidth=0.5)
# Plot the surface
clevisent = np.arange(0, 1000, 25)
cs = ax.contour(tlons, tlats, isentprs[level, :, :], clevisent,
colors='k', linewidths=1.0, linestyles='solid')
plt.clabel(cs, fontsize=10, inline=1, inline_spacing=7,
fmt='%i', rightside_up=True, use_clabeltext=True)
# Plot RH
cf = ax.contourf(tlons, tlats, isentrh[level, :, :], range(10, 106, 5),
cmap=plt.cm.gist_earth_r)
cb = plt.colorbar(cf, orientation='horizontal', extend=max, aspect=65, shrink=0.5, pad=0.05,
extendrect='True')
cb.set_label('Relative Humidity', size='x-large')
# Transform Vectors before plotting, then plot wind barbs.
ut, vt = crs.transform_vectors(ccrs.PlateCarree(), lon, lat, isentu[level, :, :].m,
isentv[level, :, :].m)
ax.barbs(tlons, tlats, ut, vt, length=6, regrid_shape=20)
# Make some titles
plt.title('{:.0f} K Isentropic Pressure (hPa), Wind (kt), Relative Humidity (percent)'
.format(isentlevs[level].m),
loc='left')
plt.title('VALID: {:s}'.format(str(vtimes[0])), loc='right')
plt.tight_layout()
Explanation: Plotting the Isentropic Analysis
End of explanation
# Calculate Montgomery Streamfunction and scale by 10^-2 for plotting
msf = mcalc.montgomery_streamfunction(isenthgt, isenttmp) / 100.
# Choose a level to plot, in this case 296 K
level = 0
fig = plt.figure(1, figsize=(17., 12.))
add_metpy_logo(fig, 120, 250, size='large')
ax = plt.subplot(111, projection=crs)
ax.set_extent(*bounds, crs=ccrs.PlateCarree())
ax.coastlines('50m', edgecolor='black', linewidth=0.75)
ax.add_feature(states_provinces, edgecolor='black', linewidth=0.5)
# Plot the surface
clevmsf = np.arange(0, 4000, 5)
cs = ax.contour(tlons, tlats, msf[level, :, :], clevmsf,
colors='k', linewidths=1.0, linestyles='solid')
plt.clabel(cs, fontsize=10, inline=1, inline_spacing=7,
fmt='%i', rightside_up=True, use_clabeltext=True)
# Plot RH
cf = ax.contourf(tlons, tlats, isentrh[level, :, :], range(10, 106, 5),
cmap=plt.cm.gist_earth_r)
cb = plt.colorbar(cf, orientation='horizontal', extend=max, aspect=65, shrink=0.5, pad=0.05,
extendrect='True')
cb.set_label('Relative Humidity', size='x-large')
# Transform Vectors before plotting, then plot wind barbs.
ut, vt = crs.transform_vectors(ccrs.PlateCarree(), lon, lat, isentu[level, :, :].m,
isentv[level, :, :].m)
ax.barbs(tlons, tlats, ut, vt, length=6, regrid_shape=20)
# Make some titles
plt.title('{:.0f} K Montgomery Streamfunction '.format(isentlevs[level].m) +
r'($10^{-2} m^2 s^{-2}$), ' +
'Wind (kt), Relative Humidity (percent)', loc='left')
plt.title('VALID: {:s}'.format(str(vtimes[0])), loc='right')
plt.tight_layout()
Explanation: Montgomery Streamfunction
The Montgomery Streamfunction, ${\psi} = gdz + CpT$, is often desired because its
gradient is proportional to the geostrophic wind in isentropic space. This can be easily
calculated with mcalc.montgomery_streamfunction.
End of explanation |
3,484 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<h1>Pau Machine Learning
Step1: <h2>1. Un exemple jouet
Step2: La sortie ci-dessus renseigne le pourcentage de variance expliqué par chacun des axes de l'ACP. Ces valeurs sont calculées grâce à la diagonalisation de la matrice ${}^T!XX$, qui représentent les corrélations entre les colonnes de $X$ (les variables de notre problème d'analyse de données). Chaque coefficient de cette matrice est défini par
Step3: <H2>2. Exemple digits
L'intérêt de l'analyse en composantes principales est de considérer des données de dimension *plus grande que 2*. Comment représenter des observations ayant un grand nombre de feature ($p=10$, $p=100$ ou $p=10^6$) ? Comment réduire la dimension en tenant compte des corrélations entre les caractères ?
<H3>2.1 Description de l'échantillon
Grâce au module sklearn, on va étudier un exemple concret
Step4: Voici par exemple une écriture du chiffre $0$ dans une matrice 8*8 pixels représentant les niveaux de gris de chaque pixel
Step5: Voici une série d'images correspondant aux 10 premières observations du dataset digits
Step6: <h3>2.2. PCA des digits 0 et 7
Attaquons maintenant notre analyse en composantes principales en essayant de représenter notre échantillon avec seulement deux composantes principales (au lieu de 64 dimensions initiales).
Step7: Le résultat ci-dessus nous dit que 27% de l'information est représenté par les deux premiers axes de l'ACP. Commençons par étudier le cas des digits 0 et 7. Comment sont représentés les observations de 0 et de 7 dans les deux premiers axes de l'ACP ?
Step8: On va représenter ces écritures selon les deux premiers axes de l'analyse en composantes principales.
Step9: Not that bad ! Grâce à un simple changement de représentation, il est maintenant très facile de détecter automatiquement un 0 ou un 7 avec un algorithme de classification en deux dimensions comme une Analyse Discrimnante Linéaire (LDA in english). Si l'on regarde de plus près cette nouvelle représentation, voici à quoi ressemble le premier axe de cette représentation
Step10: Avec une image c'est mieux
Step11: Bien sûr, les choses se compliquent avec les 10 chiffres...
Step12: A vous de jouer !
On étudie 84 peintures de Rembrant et Van Gogh grâce à l'ACP. Pour cela on représente chaque image par son histogramme de couleurs. Dans le cas présent, cela consiste à partitioner l’espace des couleurs (ici, $[0,255]^3$)
en k parties égales et, pour chaque image I, calculer la proportion $p_{Ij}$ des pixels se trouvant dans la partie j, pour $j = 1, . . . , k$. Après avoir effectué cette étape, on associe à chaque image I le vecteur numérique de taille k contenant les proportions ($p_{I1},\ldots, p_{Ik}$).
Echauffement
Les fichiers <a href="http
Step13: Visualisation avec panda. | Python Code:
%pylab --no-import-all inline
from sklearn.decomposition import PCA
matplotlib.rcParams['figure.figsize'] = 10, 10
Explanation: <h1>Pau Machine Learning : PCA algorithm
Voici le premier épisode de Pau ML, dont le but est d'échanger autour du data science. Pour commencer, nous attaquons une méthode très classique de data mining : l'analyse en composantes principales, ou PCA in english.
End of explanation
alpha = 4
size = 100
a = np.random.uniform(-1, alpha - 1, (size, 2))
b = np.random.uniform(-2, alpha - 2, (size, 2))
c = np.random.uniform(-3, alpha - 3, (size, 2))
d = np.random.uniform(0, alpha, (size, 2))
e = np.random.uniform(1, 1 + alpha, (size, 2))
f = np.random.uniform(2, 2 + alpha, (size, 2))
X = np.concatenate((a,b,c,d,e,f),axis=0)
pca = PCA(n_components=2)
plt.scatter(X[:,0],X[:,1])
pca.fit(X)
print(pca.explained_variance_ratio_)
Explanation: <h2>1. Un exemple jouet
End of explanation
newX = pca.transform(X)
print(newX)
plt.scatter(newX[:,1], newX[:,1])
Explanation: La sortie ci-dessus renseigne le pourcentage de variance expliqué par chacun des axes de l'ACP. Ces valeurs sont calculées grâce à la diagonalisation de la matrice ${}^T!XX$, qui représentent les corrélations entre les colonnes de $X$ (les variables de notre problème d'analyse de données). Chaque coefficient de cette matrice est défini par :
$$
({}^T!XX){ij} = \sum{k=1}^n X_{ki}X_{kj}, \forall i,j=1, \ldots, p.
$$
Mathématiquement, l'analyse en composantes principales est un simple changement de représentation (un changement de base): passer d'une représentation canonique (avec la base canonique) à une représentation idéale grâce à la matrice des corrélations (la base des composantes principales). Ci-dessous par exemple voici les nouvelles coordonnées de $X$ dans la nouvelle base :
End of explanation
from sklearn import datasets
#iris = datasets.load_iris()
digits = datasets.load_digits()
Explanation: <H2>2. Exemple digits
L'intérêt de l'analyse en composantes principales est de considérer des données de dimension *plus grande que 2*. Comment représenter des observations ayant un grand nombre de feature ($p=10$, $p=100$ ou $p=10^6$) ? Comment réduire la dimension en tenant compte des corrélations entre les caractères ?
<H3>2.1 Description de l'échantillon
Grâce au module sklearn, on va étudier un exemple concret : la reconnaissance d'écriture, et plus particulièrement la reconnaissance de chiffres. Dans cet exemple, chaque image représente un chiffre écrit à la main, à faible résolution (8*8 pixels). Nous sommes donc dans le cas où $p=64$.
End of explanation
digits.images[0]
Explanation: Voici par exemple une écriture du chiffre $0$ dans une matrice 8*8 pixels représentant les niveaux de gris de chaque pixel :
End of explanation
#Load the digits dataset
digits = datasets.load_digits()
#Display the first digit
for elt in range(10):
plt.figure(1, figsize=(3, 3))
plt.imshow(digits.images[elt], cmap=plt.cm.gray_r, interpolation='nearest')
plt.show()
Explanation: Voici une série d'images correspondant aux 10 premières observations du dataset digits :
End of explanation
X = digits.data
pca = PCA(n_components=2)
pca.fit(X)
print(pca.explained_variance_ratio_)
Explanation: <h3>2.2. PCA des digits 0 et 7
Attaquons maintenant notre analyse en composantes principales en essayant de représenter notre échantillon avec seulement deux composantes principales (au lieu de 64 dimensions initiales).
End of explanation
liste_0 = []
liste_7 = []
for k,elt in enumerate(digits.target):
if (elt==0):
liste_0.append(k)
if (elt==7):
liste_7.append(k)
print('On étudie '+str(len(liste_0))+' écritures du chiffre 0 et '+str(len(liste_7))+' du chiffre 7.')
X0 = digits.data[liste_0,:]
X7 = digits.data[liste_7,:]
X07 = np.concatenate((X0,X7))
pca = PCA(n_components=5)
pca.fit(X07)
Explanation: Le résultat ci-dessus nous dit que 27% de l'information est représenté par les deux premiers axes de l'ACP. Commençons par étudier le cas des digits 0 et 7. Comment sont représentés les observations de 0 et de 7 dans les deux premiers axes de l'ACP ?
End of explanation
Z07 = pca.transform(X07)
x = Z07[:,0]
y = Z07[:,1]
colors = list(digits.target[liste_0]) + list(digits.target[liste_7])
#area = np.pi * (15 * np.random.rand(N))**2
plt.scatter(x, y, c=colors, alpha=0.5)
Explanation: On va représenter ces écritures selon les deux premiers axes de l'analyse en composantes principales.
End of explanation
components = pca.components_
components[0].reshape((8,8))
Explanation: Not that bad ! Grâce à un simple changement de représentation, il est maintenant très facile de détecter automatiquement un 0 ou un 7 avec un algorithme de classification en deux dimensions comme une Analyse Discrimnante Linéaire (LDA in english). Si l'on regarde de plus près cette nouvelle représentation, voici à quoi ressemble le premier axe de cette représentation :
End of explanation
plt.figure(1, figsize=(3, 3))
plt.imshow(components[1].reshape((8,8)), cmap=plt.cm.gray_r, interpolation='nearest')
plt.show()
Explanation: Avec une image c'est mieux :
End of explanation
X = digits.data
pca = PCA(n_components=5)
pca.fit(X)
Z = pca.transform(X)
x = Z[:,0]
y = Z[:,1]
colors = digits.target
#area = np.pi * (15 * np.random.rand(N))**2
plt.scatter(x, y, c=colors, alpha=0.5)
plt.show()
Explanation: Bien sûr, les choses se compliquent avec les 10 chiffres...
End of explanation
#PCA for painting dataset
paint_data = np.genfromtxt("painting64.txt", delimiter=',')
print(paint_data.shape)
# PCA analyses
pca = PCA(n_components=3)
pca.fit(paint_data)
new_paint_data = pca.transform(paint_data)
x, y, z = new_paint_data[:,[0, 1, 2]].transpose()
print(pca.explained_variance_ratio_)
# plot
colors = 40*["blue"] + 44*["red"]
plt.subplot(211)
plt.scatter(x, y, color=colors)
plt.xlabel("First component")
plt.ylabel("Second component")
plt.subplot(212)
plt.scatter(x, z, color=colors)
plt.xlabel("First component")
plt.ylabel("Third component")
Explanation: A vous de jouer !
On étudie 84 peintures de Rembrant et Van Gogh grâce à l'ACP. Pour cela on représente chaque image par son histogramme de couleurs. Dans le cas présent, cela consiste à partitioner l’espace des couleurs (ici, $[0,255]^3$)
en k parties égales et, pour chaque image I, calculer la proportion $p_{Ij}$ des pixels se trouvant dans la partie j, pour $j = 1, . . . , k$. Après avoir effectué cette étape, on associe à chaque image I le vecteur numérique de taille k contenant les proportions ($p_{I1},\ldots, p_{Ik}$).
Echauffement
Les fichiers <a href="http://www.math.univ-angers.fr/~loustau/painting8.txt">painting8.txt</a> et <a href="http://www.math.univ-angers.fr/~loustau/painting64.txt">painting64.txt</a> contiennent l'histogramme des couleurs de chaque pour $k=8$ et $k=64$. Les 40 premières lignes correspondent aux tableaux de Rembrant et les 44 dernières à ceux de Van Gogh et les peintures se trouvent <a href = "http://www.math.univ-angers.fr/~loustau/painting.png"> ici </a>.
Faites une analyse en composantes principales pour séparer les peintures de Rembrant et Van Gogh.
End of explanation
import pandas as pd
from pandas.tools.plotting import scatter_matrix
df = pd.DataFrame({"Comp1": x, "Comp2": y, "Comp3": z})
pltmat = scatter_matrix(df, alpha=.6, figsize=(10, 10), diagonal='kde', marker="o")
Explanation: Visualisation avec panda.
End of explanation |
3,485 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
TensorFlow
References
Step1: Computational Graph
TensorFlow programs consist of 2 discrete sections
Step2: Session
To actually evaluate nodes, the computational graph must be run in a session. The session encapsulates the control and state of the TensorFlow runtime. Below, we create a Session object and invoke its run method to evaluate node1 and node2.
Step3: More complicated computations can be performed by combining Tensor nodes with Operation nodes. Use the tf.add node to mathematically add node1 and node2
Step4: Placeholders
TensorBoard will show an uninteresting, static graph at this point. By adding external inputs (Placeholders) a dynamic value can be added later
Step5: Make the graph more complex by adding another operation
Step6: Variables
To make the model trainable, add Variables for trainable parameters
Step7: Initialize all variables with a special operation. Until this point, they are uninitialized
Step8: Because x is a placeholder, linear_model can be evaluated for several x values simultaneously
Step9: Loss Function
The loss function measures how far apart the current model is from the actual data. Use a sum of squared error function to see how far off 'y' is from what is produced from 'linear_model=W * x + b' run with x=[1,2,3,4]
Step10: The values of W and b need to be updated in order to get a perfect fit. We can manually figure out what they should be in order to get the right y output (with a loss of 0)
Step11: tf.train API
TensorFlow optimizers will modify each variable to automatically minimize the loss function. Gradient descent is the most simple optimizer. It modifies each variable by the magnitude of the derivative of less w.r.t. that variable
Step12: The above values are the final model parameters which minimize the loss function!
Complete Program
Everything done above is compiled below
Step13: TensorBoard Graphs
The following produces a simple TensorBoard graph. It must be run from the containing directory and then can be viewed at the local web browser address below
* Reference | Python Code:
import tensorflow as tf
Explanation: TensorFlow
References:
* TensorFlow Getting Started
* Tensor Ranks, Shapes, and Types
Overview
TensorFlow has multiple APIs:
* TensorFlow Core: lowest level, complete control, fine tuning capabilities
* Higher Level APIs: easier to learn, abstracted. (example: tf.estimator helps manage data sets, estimators, training, and inference)
Tensors
The Tensor is the central unit of data consisting of a set of values shaped into an array of any number of dimensions (rank)
TensorFlow Core
End of explanation
node1 = tf.constant(3.0, dtype=tf.float32)
node2 = tf.constant(4.0) # also tf.float32 implicitly
print(node1, node2)
Explanation: Computational Graph
TensorFlow programs consist of 2 discrete sections:
1. Building the computational graph
2. Running the computational graph
The computational graph is a series of TF operations arranged into a graph of nodes. Each node takes zero or more tensors as inputs and produces a tensor as an output.
Constants are a type of node which takes no inputs and will output an internally stored value. Values are initialized with tf.constant and can never change. Printing the nodes gives tensor node metadata, not the values of the nodes.
End of explanation
sess = tf.Session()
print(sess.run([node1, node2]))
Explanation: Session
To actually evaluate nodes, the computational graph must be run in a session. The session encapsulates the control and state of the TensorFlow runtime. Below, we create a Session object and invoke its run method to evaluate node1 and node2.
End of explanation
node3 = tf.add(node1, node2)
print(node3)
print(sess.run(node3))
Explanation: More complicated computations can be performed by combining Tensor nodes with Operation nodes. Use the tf.add node to mathematically add node1 and node2:
End of explanation
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b # + provides a shortcut for tf.add(a, b)
print(sess.run(adder_node, {a: 3, b: 4.5}))
print(sess.run(adder_node, {a: [1, 3], b: [2, 4]}))
Explanation: Placeholders
TensorBoard will show an uninteresting, static graph at this point. By adding external inputs (Placeholders) a dynamic value can be added later:
End of explanation
add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b: 4.5}))
Explanation: Make the graph more complex by adding another operation:
End of explanation
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b
Explanation: Variables
To make the model trainable, add Variables for trainable parameters:
End of explanation
init = tf.global_variables_initializer()
sess.run(init)
Explanation: Initialize all variables with a special operation. Until this point, they are uninitialized:
End of explanation
Sessionprint(sess.run(linear_model, {x: [1, 2, 3, 4]}))
Explanation: Because x is a placeholder, linear_model can be evaluated for several x values simultaneously:
End of explanation
y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]}))
Explanation: Loss Function
The loss function measures how far apart the current model is from the actual data. Use a sum of squared error function to see how far off 'y' is from what is produced from 'linear_model=W * x + b' run with x=[1,2,3,4]
End of explanation
fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]}))
Explanation: The values of W and b need to be updated in order to get a perfect fit. We can manually figure out what they should be in order to get the right y output (with a loss of 0):
End of explanation
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
sess.run(init) # reset values to incorrect defaults.
for i in range(1000):
sess.run(train, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]})
print(sess.run([W, b]))
Explanation: tf.train API
TensorFlow optimizers will modify each variable to automatically minimize the loss function. Gradient descent is the most simple optimizer. It modifies each variable by the magnitude of the derivative of less w.r.t. that variable
End of explanation
# Model parameters
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)
# loss
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares
# optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# training data
x_train = [1, 2, 3, 4]
y_train = [0, -1, -2, -3]
# training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
sess.run(train, {x: x_train, y: y_train})
# evaluate training accuracy
curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))
Explanation: The above values are the final model parameters which minimize the loss function!
Complete Program
Everything done above is compiled below:
End of explanation
g = tf.Graph()
with g.as_default():
a = tf.placeholder(tf.float32, name="node1")
b = tf.placeholder(tf.float32, name="node2")
c = a + b
tf.summary.FileWriter("logs", g).close()
#from this notebook's directory run > tensorboard --logdir=logs
#then open TensorBoard at: http://localhost:6006/#graphs
Explanation: TensorBoard Graphs
The following produces a simple TensorBoard graph. It must be run from the containing directory and then can be viewed at the local web browser address below
* Reference: Viewing TensorFlow Graphs in Jupyter Notebooks
End of explanation |
3,486 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
IST256 Lesson 11
Web Services and API's
Assigned Reading
https
Step1: A. http
Step2: A. 2
B. 3
C. 4
D. 5
Vote Now | Python Code:
import requests
w = 'http://httpbin.org/get'
x = { 'a' :'b', 'c':'d'}
z = { 'w' : 'r'}
response = requests.get(w, params = x, headers = z)
print(response.url)
Explanation: IST256 Lesson 11
Web Services and API's
Assigned Reading
https://ist256.github.io/spring2020/readings/Web-APIs-In-Python.html
Links
Participation: https://poll.ist256.com
Zoom Chat!
FEQT (Future Exam Questions Training) 1
What prints on the last line of this program?
End of explanation
import requests # <= load up a bunch of pre-defined functions from the requests module
w = 'http://httpbin.org/ip' # <= string
response = requests.get(w) # <= w is a url. HTTP POST/GET/PUT/DELETE Verbs of HTTP
response.raise_for_status() # <= response code.if not 2??, throw exception 4 client 5 server
d = response.json() #<= de-serilaize!
d['origin']
Explanation: A. http://httpbin.org/get?a=b
B. http://httpbin.org/get?c=d
C. http://httpbin.org/get?a=b&c=d
D. http://httpbin.org/get
Vote Now: https://poll.ist256.com
FEQT (Future Exam Questions Training) 2
Which line de-serializes the response?
End of explanation
import requests
url = "http://data.fixer.io/api/latest?access_key=159f1a48ad7a3d6f4dbe5d5a"
response = requests.get(url)
response.json()
Explanation: A. 2
B. 3
C. 4
D. 5
Vote Now: https://poll.ist256.com
Agenda
Lesson 10 Homework Solution
A look at web API's
Places to find web API's
How to read API documentation
Examples of using API's
Connect Activity
Question: A common two-step verification process uses by API's discussed in the reading is
A. OAUTH2
B. Multi-Factor
C. API Key in Header
D. JSON format
Vote Now: https://poll.ist256.com
The Web Has Evolved….
From User-Consumption
Check the news / weather in your browser
Search the web for "George Washington's birthday"
Internet is for people.
To Device-Consumption
Get news/ weather alerts on your Phone
Ask Alexa “When is George Washingon's Birthday?"
Internet of Things.
Device Consuption Requires a Web API
API = Application Program Interface. In essence is a formal definition of functions exposed by a service.
Web API - API which works over HTTP.
In essence you can call functions and access services using the HTTP protocol.
Basic use starts with an HTTP request and the output is typically a JSON response.
We saw examples of this previously with:
Open Street Maps Geocoding: https://nominatim.openstreetmap.org/search?q=address&format=json
Weather Data Service: https://openweathermap.org
Thanks to APIs' we can write programs to interact with a variety of services.
Finding API's requires research…
Start googling…"foreign exchange rate api"
Then start reading the documentation on fixer.io …
Then start hacking away in Python …
End of explanation |
3,487 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Write a function
Step1: Cyclic Rotation | Python Code:
A = [3, 8, 9, 7, 6]
print A[-1:]
B = A[-1:] + A[1:]
print B
B = A[-1:] + A[:-1]
print B
K = 3
print K
print len(A)
C = B = A[-(3):] + A[:-(3)]
print C
Explanation: Write a function:
class Solution { public int[] solution(int[] A, int K); }
that, given a zero-indexed array A consisting of N integers and an integer K, returns the array A rotated K times.
For example, given array A = [3, 8, 9, 7, 6] and K = 3, the function should return [9, 7, 6, 3, 8].
Assume that:
N and K are integers within the range [0..100];
each element of array A is an integer within the range [−1,000..1,000].
End of explanation
def solution(A,K):
if len(A) == 0:
return A
elif K >= len(A):
M = K - (K/len(A)) * len(A)
return A[-(M):] + A[:-(M)]
else:
return A[-(K):] + A[:-(K)]
print solution(A,K)
Explanation: Cyclic Rotation
End of explanation |
3,488 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Tables to Networks, Networks to Tables
Networks can be represented in a tabular form in two ways
Step1: At this point, we have our stations and trips data loaded into memory.
How we construct the graph depends on the kind of questions we want to answer, which makes the definition of the "unit of consideration" (or the entities for which we are trying to model their relationships) is extremely important.
Let's try to answer the question
Step2: Then, let's iterate over the stations DataFrame, and add in the node attributes.
Step3: In order to answer the question of "which stations are important", we need to specify things a bit more. Perhaps a measure such as betweenness centrality or degree centrality may be appropriate here.
The naive way would be to iterate over all the rows. Go ahead and try it at your own risk - it may take a long time
Step4: First off, let's figure out how dense the graph is. The graph's density is the number of edges divided by the total number of nodes.
NetworkX provides an implementation of graph density, but it assumes self-loops are not allowed. (Self-loops are edges from one node to itself.) Let's see what the graph density is
Step5: Applying what we learned earlier on, let's use the betweenness centrality metric.
Step6: Applying what we learned earlier, let's use the "degree centrality" metric as well.
Step7: The code above should have demonstrated to you the basic logic behind storing graph data in a human-readable format. For the richest data format, you can store a node list with attributes, and an edge list (a.k.a. adjacency list) with attributes.
Saving NetworkX Graph Files
NetworkX's API offers many formats for storing graphs to disk. If you intend to work exclusively with NetworkX, then pickling the file to disk is probably the easiest way.
To write to disk | Python Code:
stations = pd.read_csv('datasets/divvy_2013/Divvy_Stations_2013.csv', parse_dates=['online date'], index_col='id')
stations
trips = pd.read_csv('datasets/divvy_2013/Divvy_Trips_2013.csv', parse_dates=['starttime', 'stoptime'], index_col=['trip_id'])
trips = trips.sort()
trips
Explanation: Tables to Networks, Networks to Tables
Networks can be represented in a tabular form in two ways: As an adjacency list with edge attributes stored as columnar values, and as a node list with node attributes stored as columnar values.
Storing the network data as a single massive adjacency table, with node attributes repeated on each row, can get unwieldy, especially if the graph is large, or grows to be so. One way to get around this is to store two files: one with node data and node attributes, and one with edge data and edge attributes.
The Divvy bike sharing dataset is one such example of a network data set that has been stored as such.
Loading Node Lists and Adjacency Lists
Let's use the Divvy bike sharing data set as a starting point. The Divvy data set is comprised of the following data:
Stations and metadata (like a node list with attributes saved)
Trips and metadata (like an edge list with attributes saved)
The README.txt file in the Divvy directory should help orient you around the data.
End of explanation
G = nx.DiGraph()
Explanation: At this point, we have our stations and trips data loaded into memory.
How we construct the graph depends on the kind of questions we want to answer, which makes the definition of the "unit of consideration" (or the entities for which we are trying to model their relationships) is extremely important.
Let's try to answer the question: "What are the most popular trip paths?" In this case, the bike station is a reasonable "unit of consideration", so we will use the bike stations as the nodes.
To start, let's initialize an directed graph G.
End of explanation
for r, d in stations.iterrows(): # call the pandas DataFrame row-by-row iterator
G.add_node(r, attr_dict=d.to_dict())
Explanation: Then, let's iterate over the stations DataFrame, and add in the node attributes.
End of explanation
# # Run the following code at your own risk :)
# for r, d in trips.iterrows():
# start = d['from_station_id']
# end = d['to_station_id']
# if (start, end) not in G.edges():
# G.add_edge(start, end, count=1)
# else:
# G.edge[start][end]['count'] += 1
for (start, stop), d in trips.groupby(['from_station_id', 'to_station_id']):
G.add_edge(start, stop, count=len(d))
Explanation: In order to answer the question of "which stations are important", we need to specify things a bit more. Perhaps a measure such as betweenness centrality or degree centrality may be appropriate here.
The naive way would be to iterate over all the rows. Go ahead and try it at your own risk - it may take a long time :-). Alternatively, I would suggest doing a pandas groupby.
End of explanation
G.edges(data=True)
Explanation: First off, let's figure out how dense the graph is. The graph's density is the number of edges divided by the total number of nodes.
NetworkX provides an implementation of graph density, but it assumes self-loops are not allowed. (Self-loops are edges from one node to itself.) Let's see what the graph density is
End of explanation
centralities = nx.betweenness_centrality(G, weight='count')
sorted(centralities.items(), key=lambda x:x[1], reverse=True)
import matplotlib.pyplot as plt
%matplotlib inline
plt.bar(centralities.keys(), centralities.values())
Explanation: Applying what we learned earlier on, let's use the betweenness centrality metric.
End of explanation
decentrality = nx.degree_centrality(G)
plt.bar(decentrality.keys(), decentrality.values())
Explanation: Applying what we learned earlier, let's use the "degree centrality" metric as well.
End of explanation
nx.write_gpickle(G, 'datasets/divvy_2013/divvy_graph.pkl')
Explanation: The code above should have demonstrated to you the basic logic behind storing graph data in a human-readable format. For the richest data format, you can store a node list with attributes, and an edge list (a.k.a. adjacency list) with attributes.
Saving NetworkX Graph Files
NetworkX's API offers many formats for storing graphs to disk. If you intend to work exclusively with NetworkX, then pickling the file to disk is probably the easiest way.
To write to disk:
nx.write_gpickle(G, handle)
To load from disk:
G = nx.read_gpickle(handle)
Let's write the graph to disk so that we can analyze it further in other notebooks.
End of explanation |
3,489 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Severe Weather Forecasting with Python and Data Science Tools
Step1: Part 1
Step2: We will be using model output from the control run of the Center for Analysis and Prediction of Storms 2015 Storm-Scale Ensemble Forecast system. The model output for this exercise is included with the hagelslag package, but additional variables can be downloaded from the Unidata RAMADDA server or from my personal page. Please untar the data in a local directory and modify the model_path variable below to point to the spring2015_unidata directory.
Step3: The max updraft helicity map over the full period shows mutiple long and intense tracks in the central Plains.
Step4: To investigate the timing of the tracks, we can use this interactive widget to explore the tracks through time and to zoom in on areas of interest.
Step5: Storm Track Identification with the Enhanced Watershed
Our first data science tool is the enhanced watershed (Lakshmanan 2009), which is used for identifying features in gridded data. The original watershed transform identifies regions from an image or grid by finding local maxima and then growing objects from those maxima in discrete steps by looking for adjacent pixels with at least a certain intensity in an iterative fashion. The traditional watershed uses an intensity threshold as the stopping criterion for growth, which can produce unrealistic looking objects. The enhanced watershed first discretizes the data and then uses size and relative intensity thresholds to identify discrete objects. Buffer regions are also created around each object.
The enhanced watershed has the following tunable parameters
Step6: Once you find a desirable set of enhanced watershed parameters, input them below and generate storm objects for all time steps.
Step7: Object Tracking
Tracking storms over time provides useful information about their evolution and threat potential. However, storm tracking is a challenging problem due to storms forming, splitting, merging, and dying. Basic object-based storm tracking methods compare the locations of storms at one time step with the locations at the previous time steps and then find an optimal way to match storms from the two sets appropriately.
Step8: Part 2
Step9: First, we will upload the data using the pandas library. The data are stored in DataFrames, a 2-dimensional data structure in which each row is a record, and each column contains data of the same type. DataFrames allow arbitrary indexing of the rows and columns. They are based on the R data frame. The individual steps of each track are stored in track_step_data, and information about the full tracks are stored in track_total_data. The dataset contains 117 columns of data.
Step10: The extracted hail sizes show a skewed distribution with a long tail. Storms with a hail size of 0 were not matched with an observed track and should be excluded when building a regression model.
Step11: The simplest and generally first choice for a statistical model is an ordinary linear regression. The model minimizes the mean squared error over the full training set. Since we used updraft helicity to identify the storm tracks, we start with building two linear models using the maximum updraft helicity and observed hail size. We first fit a linear model of the form $y=ax+b$. Then we fit a power-law model (think Z-R relationship) of the form $\ln(y)=a\ln(x) + b$. The training data and the two linear models are plotted below.
Step12: While the linear regression fit does show a slight positive relationship with hail size, it also shows a large amount of variance. We could try to train a multiple linear regression from a subset of all the variables, but finding that subset is time consuming, and the resulting model still relies on the assumption of constant variance and normality.
Alternatively, we could use a decision tree, which is a popular model from the machine learning community that performs variable selection, is robust against outliers and missing data, and does not rely on any parametric data model assumptions. While individual decision trees do not provide very high accuracy, randomized ensembles of decision trees are consistently among the best performing models in many applications. We will experiment with the Random Forest, a popular decision tree ensemble due to its ease of use and generally high accuracy.
Step13: Random forests provide a measure of how much each input variable affects the performance of the model called variable importance. It is a normalized measure of the decrease in error produced by each variable.
Step14: We can validate the accuracy of the two models by comparing the hail size predictions for 4 June 2015 from each model. The root mean squared errors from each model are similar, but the random forest appears to be better at spreading the predictions over a larger range of hail sizes.
Step15: Since each tree in the random forest produces an independent output, a probability density function can be generated from them for each prediction. To translate the predictions into probabilities, two methods can be used. A kernel density estimate (KDE) uses a moving window to determine probability based on the concentration of events at particular values. The alternative approach is to assume a parametric distribution, such as a Gaussian, and fit the distribution parameters to your predictions. As the KDE is non-parametric, it is much better at identifying the longer tails and secondary peaks that may hint at the chance for extreme hail. The example below shows how the KDE and Gaussian distributions compare for all of the June 4 predictions. | Python Code:
%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
from mpl_toolkits.basemap import Basemap
from IPython.display import display, Image
from ipywidgets import widgets, interact
from scipy.ndimage import gaussian_filter, find_objects
from copy import deepcopy
from glob import glob
import matplotlib.patches as patches
Explanation: Severe Weather Forecasting with Python and Data Science Tools: Interactive Demo
David John Gagne, University of Oklahoma and NCAR
Introduction
Severe weather forecasting has entered an age of unprecedented access to large model and observational datasets with even greater hordes of data in the pipeline. With multiple ensembles of convection-allowing models available and an increasing variety of observations derived from radar, satellite, surface, upper air, and crowd-sourcing, forecasters can easily be overwhelmed with guidance. Without ways to organize, synthesize, and visualize the data in a useful manner for forecasters, the pile of new models and observations will languish unused and will not fulfill their full potential. An even worse outcome would be to take the human forecasters completely out of the loop and trust the models, which is a way fraught with peril. Data science tools offer ways to synthesize essential information from many disparate data sources while also quantifying uncertainty. When forecasters use the tools properly, they can identify potential hazards and the associated spatial and time uncertainties more quickly by using the output of the tools to help target their domain knowledge.
This module demonstrates how data science tools from the image processing and machine learning families can be used to create a forecast of severe hail. It aims to teach the advantages, challenges, and limitations of these tools through hands-on interaction.
End of explanation
from hagelslag.processing.EnhancedWatershedSegmenter import EnhancedWatershed
from hagelslag.data.ModelOutput import ModelOutput
from hagelslag.processing.ObjectMatcher import ObjectMatcher, shifted_centroid_distance, centroid_distance
from hagelslag.processing.STObject import STObject
from hagelslag.processing.tracker import label_storm_objects, extract_storm_objects
Explanation: Part 1: Storm Track Identification
We will be using the hagelslag library to perform object-based data processing of convection-allowing model output.
End of explanation
model_path = "../testdata/spring2015_unidata/"
ensemble_name = "SSEF"
member ="wrf-s3cn_arw"
run_date = datetime(2015, 6, 4)
# We will be using the uh_max (hourly max 2-5 km Updraft Helicity) variable for this exercise
# cmpref (simulated composite radar reflectivity) is also available.
variable = "uh_max"
start_date = run_date + timedelta(hours=12)
end_date = run_date + timedelta(hours=29)
model_grid = ModelOutput(ensemble_name,
member,
run_date,
variable,
start_date,
end_date,
model_path,
map_file="../mapfiles/ssef2015.map",
single_step=False)
model_grid.load_data()
model_grid.load_map_info("../mapfiles/ssef2015.map")
Explanation: We will be using model output from the control run of the Center for Analysis and Prediction of Storms 2015 Storm-Scale Ensemble Forecast system. The model output for this exercise is included with the hagelslag package, but additional variables can be downloaded from the Unidata RAMADDA server or from my personal page. Please untar the data in a local directory and modify the model_path variable below to point to the spring2015_unidata directory.
End of explanation
lon_range = (-105, -91)
lat_range = (35, 44)
basemap = Basemap(projection="cyl",
resolution="l",
llcrnrlon=lon_range[0],
urcrnrlon=lon_range[1],
llcrnrlat=lat_range[0],
urcrnrlat=lat_range[1])
plt.figure(figsize=(10,8))
basemap.drawstates()
plt.contourf(model_grid.lon,
model_grid.lat,
model_grid.data.max(axis=0),
np.arange(25,225,25),
extend="max",
cmap="YlOrRd")
#plt.colorbar(shrink=0.6, fraction=0.05, pad=0.02 )
title_info = plt.title("Max Updraft Helicity {0}-{1}".format(start_date.strftime("%d %B %y %H:%M"),
end_date.strftime("%d %B %y %H:%M")),
fontweight="bold", fontsize=14)
plt.savefig("uh_swaths.png", dpi=200, bbox_inches="tight")
Explanation: The max updraft helicity map over the full period shows mutiple long and intense tracks in the central Plains.
End of explanation
zoomable_bmap = Basemap(projection="cyl",
resolution="l",
llcrnrlon=model_grid.lon.min(),
llcrnrlat=model_grid.lat.min(),
urcrnrlon=model_grid.lon.max(),
urcrnrlat=model_grid.lat.max(),
fix_aspect=False)
def model_time_viewer(lon_range, lat_range, hour):
#lon_range = (-108, -90)
#lat_range = (35, 45)
#basemap = Basemap(projection="cyl",
# resolution="l",
# llcrnrlon=lon_range[0],
# urcrnrlon=lon_range[1],
# llcrnrlat=lat_range[0],
# urcrnrlat=lat_range[1])
plt.figure(figsize=(12,8))
zoomable_bmap.drawstates()
zoomable_bmap.drawcoastlines()
zoomable_bmap.drawcountries()
plt.contourf(model_grid.lon,
model_grid.lat,
model_grid.data[hour - model_grid.start_hour],
#np.arange(3, 80, 3),
np.arange(25,225,25),
extend="max",
cmap="YlOrRd")
plt.colorbar(shrink=0.6, fraction=0.05, pad=0.02)
title_info = plt.title("Max Updraft Helicity Valid {0}".format((run_date + timedelta(hours=hour)).strftime(
"%d %B %Y %H UTC")))
plt.xlim(*lon_range)
plt.ylim(*lat_range)
plt.show()
lon_slider = widgets.IntRangeSlider(min=int(model_grid.lon.min()),
max=int(model_grid.lon.max()),
step=1, value=(-108, -90))
lat_slider = widgets.IntRangeSlider(min=int(model_grid.lat.min()),
max=int(model_grid.lat.max()),
value=(35,45),
step=1)
hour_slider = widgets.IntSlider(min=model_grid.start_hour, max=model_grid.end_hour, step=1, value=0)
w = widgets.interactive(model_time_viewer, lon_range=lon_slider, lat_range=lat_slider, hour=hour_slider)
display(w)
Explanation: To investigate the timing of the tracks, we can use this interactive widget to explore the tracks through time and to zoom in on areas of interest.
End of explanation
plt.figure(figsize=(10 ,5))
model_grid.data.shape
label_grid = label_storm_objects(model_grid.data[11], "hyst", 10, 50, min_area=2, max_area=100)
storm_objs = extract_storm_objects(label_grid, model_grid.data[11], model_grid.x, model_grid.y, np.array([0]))
print(storm_objs)
plt.subplot(1, 2, 1)
plt.title("Original UH Track")
plt.contourf(model_grid.x / 1000, model_grid.y / 1000, model_grid.data[11], np.arange(25, 225, 25))
plt.xlim(-600, -500)
plt.ylim(-200, -150)
plt.subplot(1, 2, 2)
for storm_obj in storm_objs[0]:
print(storm_obj.timesteps[0].max())
plt.contourf(storm_obj.x[0] / 1000, storm_obj.y[0] / 1000, storm_obj.timesteps[0], np.arange(25, 225, 25))
plt.xlim(-600, -500)
plt.ylim(-200, -150)
plt.colorbar()
plt.title("Extracted UH Track")
plt.savefig("extracted_uh_comp.png", dpi=200, bbox_inches="tight")
def ew_demo(min_max, step_val, size_val=50, delta_val=5, time=12):
ew = EnhancedWatershed(min_max[0],step_val,min_max[1],size_val,delta_val)
fig, ax = plt.subplots(figsize=(12,8))
basemap.drawstates()
labels = ew.label(gaussian_filter(model_grid.data[time - model_grid.start_hour], 1))
objs = find_objects(labels)
plt.contourf(model_grid.lon,
model_grid.lat,
labels,
np.arange(1,labels.max()),
extend="max",
cmap="Set1")
for obj in objs:
sy = model_grid.lat[obj[0].start-1, obj[1].start-1]
sx = model_grid.lon[obj[0].start-1, obj[1].start-1]
wx = model_grid.lon[obj[0].stop + 1, obj[1].stop + 1] - sx
wy = model_grid.lat[obj[0].stop + 1, obj[1].stop + 1] - sy
ax.add_patch(patches.Rectangle((sx, sy), wx, wy, fill=False, color="red"))
plt.xlim(*lon_range)
plt.ylim(*lat_range)
plt.grid()
plt.title("Enhanced Watershed Objects Min: {0:d} Step: {1:d} Max: {2:d} Size: {3:d} Delta: {4:d}) Time: {5:d}".format(min_max[0],
step_val,
min_max[1],
size_val,
delta_val,
time),
fontsize=14, fontweight="bold")
plt.show()
#plt.savefig("ew_objs.pdf", bbox_inches="tight")
minmax_slider = widgets.IntRangeSlider(min=25, max=225, step=25, value=(25,225))
step_slider = widgets.IntSlider(min=1, max=10, step=1, value=1)
size_slider = widgets.IntSlider(min=5, max=300, step=5, value=50)
delta_slider = widgets.IntSlider(min=10, max=100, step=10, value=20)
time_slider = widgets.IntSlider(min=model_grid.start_hour, max=model_grid.end_hour, step=1, value=24)
w = widgets.interactive(ew_demo,
min_max=minmax_slider,
step_val=step_slider,
size_val=size_slider,
delta_val=delta_slider,
time=time_slider)
display(w)
Explanation: Storm Track Identification with the Enhanced Watershed
Our first data science tool is the enhanced watershed (Lakshmanan 2009), which is used for identifying features in gridded data. The original watershed transform identifies regions from an image or grid by finding local maxima and then growing objects from those maxima in discrete steps by looking for adjacent pixels with at least a certain intensity in an iterative fashion. The traditional watershed uses an intensity threshold as the stopping criterion for growth, which can produce unrealistic looking objects. The enhanced watershed first discretizes the data and then uses size and relative intensity thresholds to identify discrete objects. Buffer regions are also created around each object.
The enhanced watershed has the following tunable parameters:
* min, step, max: parameters to quantize the grid into a discrete number of levels
* size: growth of an object is stopped after it reaches the specified number of grid points in area
* delta: the maximum range of values contained within an object
Exercise: Manual Tuning
Pick a model time step and tune the enhanced watershed parameters until the objects look reasonable. Note how changing parameter values affects the shape of the objects. See how your chosen set of parameters handles other time steps. Finally, see what parameter settings produce particularly poor objects. If you find either a particularly good representation or a hilariously bad one, right-click the image, save it, and email the image to me at [email protected].
End of explanation
def get_forecast_objects(model_grid, ew_params, min_size, gaussian_window):
ew = EnhancedWatershed(*ew_params)
model_objects = []
for h, hour in enumerate(np.arange(model_grid.start_hour, model_grid.end_hour + 1)):
print("{0:02d}".format(hour))
hour_labels = ew.size_filter(ew.label(gaussian_filter(model_grid.data[h], gaussian_window)), min_size)
obj_slices = find_objects(hour_labels)
num_slices = len(obj_slices)
model_objects.append([])
if num_slices > 0:
for sl in obj_slices:
model_objects[-1].append(STObject(model_grid.data[h][sl],
np.where(hour_labels[sl] > 0, 1, 0),
model_grid.x[sl],
model_grid.y[sl],
model_grid.i[sl],
model_grid.j[sl],
hour,
hour,
dx=3000))
if h > 0:
dims = model_objects[-1][-1].timesteps[0].shape
model_objects[-1][-1].estimate_motion(hour, model_grid.data[h-1], dims[1], dims[0])
return model_objects
min_thresh = 25
max_thresh = 225
step = 1
max_size = 100
min_size = 12
delta = 100
gaussian_filter_size = 1
model_objects = get_forecast_objects(model_grid, (min_thresh, step, max_thresh, max_size, delta),
min_size, gaussian_filter_size)
Explanation: Once you find a desirable set of enhanced watershed parameters, input them below and generate storm objects for all time steps.
End of explanation
def track_forecast_objects(input_model_objects, model_grid, object_matcher):
model_objects = deepcopy(input_model_objects)
hours = np.arange(int(model_grid.start_hour), int(model_grid.end_hour) + 1)
tracked_model_objects = []
for h, hour in enumerate(hours):
past_time_objs = []
for obj in tracked_model_objects:
# Potential trackable objects are identified
if obj.end_time == hour - 1:
past_time_objs.append(obj)
# If no objects existed in the last time step, then consider objects in current time step all new
if len(past_time_objs) == 0:
tracked_model_objects.extend(deepcopy(model_objects[h]))
# Match from previous time step with current time step
elif len(past_time_objs) > 0 and len(model_objects[h]) > 0:
assignments = object_matcher.match_objects(past_time_objs, model_objects[h], hour - 1, hour)
unpaired = list(range(len(model_objects[h])))
for pair in assignments:
past_time_objs[pair[0]].extend(model_objects[h][pair[1]])
unpaired.remove(pair[1])
if len(unpaired) > 0:
for up in unpaired:
tracked_model_objects.append(model_objects[h][up])
#print("Tracked Model Objects: {0:03d} Hour: {1:02d}".format(len(tracked_model_objects), hour))
return tracked_model_objects
def make_tracks(dist_weight, max_distance):
global tracked_model_objects
object_matcher = ObjectMatcher([shifted_centroid_distance, centroid_distance],
np.array([dist_weight, 1-dist_weight]), np.array([max_distance * 1000] * 2))
tracked_model_objects = track_forecast_objects(model_objects, model_grid, object_matcher)
color_list = ["violet", "cyan", "blue", "green", "purple", "darkgreen", "teal", "royalblue"]
color_arr = np.tile(color_list, len(tracked_model_objects) // len(color_list) + 1)
plt.figure(figsize=(10, 8))
basemap.drawstates()
plt.contourf(model_grid.lon,
model_grid.lat,
model_grid.data.max(axis=0),
np.arange(25,225,25),
extend="max",
cmap="YlOrRd")
plt.colorbar(shrink=0.6, fraction=0.05, pad=0.02 )
for t, tracked_model_object in enumerate(tracked_model_objects):
traj = tracked_model_object.trajectory()
t_lon, t_lat = model_grid.proj(traj[0], traj[1], inverse=True)
plt.plot(t_lon, t_lat, marker='o', markersize=4, color=color_arr[t], lw=2)
#plt.barbs(t_lon, t_lat, tracked_model_object.u /3000,
# tracked_model_object.v / 3000.0, length=6,
# barbcolor=color_arr[t])
plt.title("Forecast Tracks Shifted Centroid: {0:0.1f}, Centroid: {1:0.1f}, Max Distance: {2:3d} km".format(
dist_weight, 1-dist_weight, max_distance), fontweight="bold", fontsize=14)
plt.show()
#plt.savefig("storm_tracks.png", dpi=200, bbox_inches="tight")
tracked_model_objects = None
weight_slider = widgets.FloatSlider(min=0, max=1, step=1, value=1)
dist_slider = widgets.IntSlider(min=10, max=1000, step=10, value=50)
track_w = widgets.interactive(make_tracks, dist_weight=weight_slider, max_distance=dist_slider)
display(track_w)
Explanation: Object Tracking
Tracking storms over time provides useful information about their evolution and threat potential. However, storm tracking is a challenging problem due to storms forming, splitting, merging, and dying. Basic object-based storm tracking methods compare the locations of storms at one time step with the locations at the previous time steps and then find an optimal way to match storms from the two sets appropriately.
End of explanation
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.neighbors import KernelDensity
from scipy.stats import norm
Explanation: Part 2: Hail Size Prediction with Machine Learning
Once storm tracks have been identified, data can be extracted from within each step of the storm track from the other model fields. The forecast tracks are also associated with the observed tracks using a process similar to storm tracking. Storm track data and associated hail sizes have been extracted for a set of model runs from May 20 through 3 June 2015. We will use this data to find a relationship between the model output and hail size and try to account for the uncertainty in that relationship.
First we will import some statistical and machine learning models from the scikit-learn package. The library supports a wide variety of machine learning models, which are described in great detail in the official documentation.
End of explanation
train_data_dir = "../testdata/track_data_csv_unidata_train/"
forecast_data_dir = "../testdata/track_data_csv_unidata_forecast/"
train_step_files = sorted(glob(train_data_dir + "track_step_SSEF*.csv"))
train_total_files = sorted(glob(train_data_dir + "track_total_SSEF*.csv"))
track_step_data = pd.concat(map(pd.read_csv, train_step_files), ignore_index=True)
track_total_data = pd.concat(map(pd.read_csv, train_total_files), ignore_index=True)
track_forecast_data = pd.read_csv(forecast_data_dir + "track_step_SSEF_wrf-s3cn_arw_20150604.csv")
pd.set_option('display.max_columns', track_step_data.shape[1])
print(track_step_data.shape)
track_step_data.describe()
Explanation: First, we will upload the data using the pandas library. The data are stored in DataFrames, a 2-dimensional data structure in which each row is a record, and each column contains data of the same type. DataFrames allow arbitrary indexing of the rows and columns. They are based on the R data frame. The individual steps of each track are stored in track_step_data, and information about the full tracks are stored in track_total_data. The dataset contains 117 columns of data.
End of explanation
track_step_data["Hail_Size"].hist(bins=np.arange(0,105,5))
plt.xlabel("Hail Size (mm)")
plt.ylabel("Frequency")
plt.figure(figsize=(8, 4))
from sklearn.preprocessing import PowerTransformer
plt.subplot(1, 2, 1)
idxs = (track_step_data["Hail_Size"] > 0) & (track_step_data["Hail_Size"] < 125)
plt.hist(track_step_data["Hail_Size"][idxs], bins=np.arange(0, 100, 5))
pt = PowerTransformer(method="box-cox")
bc_hail = pt.fit_transform(track_step_data.loc[idxs, ["Hail_Size"]])
plt.title("Raw Hail Sizes")
plt.ylabel("Frequency", fontsize=12)
plt.xlabel("Hail Size (mm)", fontsize=12)
plt.subplot(1, 2, 2)
log_hail= np.log(track_step_data["Hail_Size"][idxs])
plt.hist((log_hail - log_hail.mean()) / log_hail.std(), bins=np.arange(-3, 3, 0.2))
plt.title("Log-Transformed and Standardized")
plt.xlabel("log(Hail Size) Anomaly", fontsize=12)
plt.savefig("hail_size_scaled.png", dpi=200, bbox_inches="tight")
#plt.subplot(1, 3, 3)
#plt.hist(bc_hail, bins=np.arange(-3, 3, 0.2))
Explanation: The extracted hail sizes show a skewed distribution with a long tail. Storms with a hail size of 0 were not matched with an observed track and should be excluded when building a regression model.
End of explanation
# We are filtering the unmatched storm tracks and storm tracks matched with unrealistically high values
filter_idx = (track_step_data['Hail_Size'] > 0) & (track_step_data['Hail_Size'] < 100)
x_var = "uh_max_max"
print("Standard deviation", track_step_data["Hail_Size"][filter_idx].std())
print("Correlation coefficient", np.corrcoef(track_step_data[x_var][filter_idx],
track_step_data['Hail_Size'][filter_idx])[0,1])
lr = LinearRegression()
log_lr = LinearRegression()
log_lr.fit(np.log(track_step_data.loc[filter_idx,[x_var]]), np.log(track_step_data['Hail_Size'][filter_idx]))
lr.fit(track_step_data.loc[filter_idx,[x_var]], track_step_data['Hail_Size'][filter_idx])
print("Linear model:", "a", lr.coef_[0], "b",lr.intercept_)
print("Power law model:","a",log_lr.coef_[0], "b",log_lr.intercept_)
plt.scatter(track_step_data.loc[filter_idx, x_var],
track_step_data.loc[filter_idx, 'Hail_Size'], 10, 'r')
uh_test_vals = np.arange(1 , track_step_data.loc[filter_idx, x_var].max())
power_hail_vals = np.exp(log_lr.intercept_) * uh_test_vals ** log_lr.coef_[0]
hail_vals = lr.intercept_ + lr.coef_[0] * uh_test_vals
plt.plot(uh_test_vals, power_hail_vals)
plt.plot(uh_test_vals, hail_vals)
plt.xlabel(x_var)
plt.ylabel("Hail Size (mm)")
Explanation: The simplest and generally first choice for a statistical model is an ordinary linear regression. The model minimizes the mean squared error over the full training set. Since we used updraft helicity to identify the storm tracks, we start with building two linear models using the maximum updraft helicity and observed hail size. We first fit a linear model of the form $y=ax+b$. Then we fit a power-law model (think Z-R relationship) of the form $\ln(y)=a\ln(x) + b$. The training data and the two linear models are plotted below.
End of explanation
rf = RandomForestRegressor(n_estimators=500, min_samples_split=20, max_features="sqrt")
rf.fit(track_step_data.loc[filter_idx, track_step_data.columns[3:-1]], track_step_data['Hail_Size'][filter_idx])
Explanation: While the linear regression fit does show a slight positive relationship with hail size, it also shows a large amount of variance. We could try to train a multiple linear regression from a subset of all the variables, but finding that subset is time consuming, and the resulting model still relies on the assumption of constant variance and normality.
Alternatively, we could use a decision tree, which is a popular model from the machine learning community that performs variable selection, is robust against outliers and missing data, and does not rely on any parametric data model assumptions. While individual decision trees do not provide very high accuracy, randomized ensembles of decision trees are consistently among the best performing models in many applications. We will experiment with the Random Forest, a popular decision tree ensemble due to its ease of use and generally high accuracy.
End of explanation
def plot_importances(num_features):
feature_names = np.array(["{0} ({1:d})".format(f, x) for x, f in enumerate(track_step_data.columns[3:-1].values)])
feature_ranks = np.argsort(rf.feature_importances_)
plt.figure(figsize=(5,8))
plt.barh(np.arange(feature_ranks.size)[-num_features:],
rf.feature_importances_[feature_ranks][-num_features:], height=1)
plt.yticks(np.arange(feature_ranks.size)[-num_features:] + 0.5, feature_names[feature_ranks][-num_features:])
plt.ylim(feature_names.size-num_features, feature_names.size)
plt.xlabel("Normalized Importance")
plt.title("Random Forest Variable Importance")
feature_slider = widgets.IntSlider(min=1, max=100, value=10)
feature_w = widgets.interactive(plot_importances, num_features=feature_slider)
display(feature_w)
Explanation: Random forests provide a measure of how much each input variable affects the performance of the model called variable importance. It is a normalized measure of the decrease in error produced by each variable.
End of explanation
ver_idx = (track_forecast_data["Hail_Size"].values > 0) & (track_forecast_data["Hail_Size"].values < 100)
rf_preds = rf.predict(track_forecast_data.loc[ver_idx, track_forecast_data.columns[3:-1]])
lr_preds = lr.predict(track_forecast_data.loc[ver_idx,["uh_max_max"]])
rf_rmse = np.sqrt(np.mean(np.power(rf_preds - track_forecast_data.loc[ver_idx, "Hail_Size"], 2)))
lr_rmse = np.sqrt(np.mean(np.power(lr_preds - track_forecast_data.loc[ver_idx, "Hail_Size"], 2)))
plt.figure(figsize=(12, 6))
plt.subplot(1,2,1)
plt.scatter(rf_preds, track_forecast_data.loc[ver_idx, "Hail_Size"])
plt.plot(np.arange(0, 65, 5), np.arange(0, 65, 5), "k--")
plt.xlabel("Random Forest Hail Size (mm)")
plt.ylabel("Observed Hail Size (mm)")
plt.title("Random Forest Predictions RMSE: {0:0.3f}".format(rf_rmse))
plt.xlim(20,60)
plt.ylim(20,60)
plt.subplot(1,2,2)
plt.scatter(lr_preds, track_forecast_data.loc[ver_idx, "Hail_Size"])
plt.plot(np.arange(0, 65, 5), np.arange(0, 65, 5), "k--")
plt.xlabel("Linear Regression Hail Size (mm)")
plt.ylabel("Observed Hail Size (mm)")
plt.title("Linear Regression Predictions RMSE: {0:0.3f}".format(lr_rmse))
plt.xlim(20,60)
plt.ylim(20,60)
Explanation: We can validate the accuracy of the two models by comparing the hail size predictions for 4 June 2015 from each model. The root mean squared errors from each model are similar, but the random forest appears to be better at spreading the predictions over a larger range of hail sizes.
End of explanation
kde = KernelDensity(bandwidth=4)
bins = np.arange(0, 100)
bins = bins.reshape((bins.size, 1))
rf_tree_preds = np.array([t.predict(track_forecast_data.loc[ver_idx, track_forecast_data.columns[3:-1]]) for t in rf.estimators_])
mean_preds = rf_tree_preds.mean(axis=0)
sd_preds = rf_tree_preds.std(axis=0)
rf_pdfs = []
for r in range(rf_tree_preds.shape[1]):
kde.fit(rf_tree_preds[:, r:r+1])
rf_pdfs.append(np.exp(kde.score_samples(bins)))
rf_pdfs = np.array(rf_pdfs)
rf_cdfs = rf_pdfs.cumsum(axis=1)
pred_sorted = np.argsort(mean_preds)
def plot_pdfs(min_max):
plt.figure(figsize=(15,5))
plt.subplot(1,2,1)
plt.title("Random Forest KDE Prediction PDFs")
for r in rf_pdfs[pred_sorted][min_max[0]:min_max[1]+1]:
plt.plot(bins, r)
plt.ylim(0, 0.1)
plt.xlabel("Forecast Hail Size (mm)")
plt.ylabel("Probability Density")
plt.xticks(np.arange(0, 105, 5))
plt.grid()
plt.subplot(1,2,2)
plt.title("Random Forest Gaussian Prediction PDFs")
for r2, mean_pred in enumerate(mean_preds[pred_sorted][min_max[0]:min_max[1]+1]):
plt.plot(bins, norm.pdf(bins, loc=mean_pred, scale=sd_preds[pred_sorted][r2]))
plt.ylim(0, 0.1)
plt.xlabel("Forecast Hail Size (mm)")
plt.ylabel("Probability Density")
plt.xticks(np.arange(0, 105, 5))
plt.grid()
plt.show()
mm_slider = widgets.IntRangeSlider(min=0, max=rf_pdfs.shape[0])
display(widgets.interactive(plot_pdfs, min_max=mm_slider))
Explanation: Since each tree in the random forest produces an independent output, a probability density function can be generated from them for each prediction. To translate the predictions into probabilities, two methods can be used. A kernel density estimate (KDE) uses a moving window to determine probability based on the concentration of events at particular values. The alternative approach is to assume a parametric distribution, such as a Gaussian, and fit the distribution parameters to your predictions. As the KDE is non-parametric, it is much better at identifying the longer tails and secondary peaks that may hint at the chance for extreme hail. The example below shows how the KDE and Gaussian distributions compare for all of the June 4 predictions.
End of explanation |
3,490 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Метод сопряжённых градиентов (Conjugate gradient method)
Step1: Распределение собственных значений
Step2: Правильный ответ
Step3: Реализация метода сопряжённых градиентов
Step4: График сходимости
Step5: Неквадратичная функция
Step6: Реализация метода Флетчера-Ривса
Step7: График сходимости
Step8: Время выполнения | Python Code:
import numpy as np
n = 100
# Random
# A = np.random.randn(n, n)
# A = A.T.dot(A)
# Clustered eigenvalues
A = np.diagflat([np.ones(n//4), 10 * np.ones(n//4), 100*np.ones(n//4), 1000* np.ones(n//4)])
U = np.random.rand(n, n)
Q, _ = np.linalg.qr(U)
A = Q.dot(A).dot(Q.T)
A = (A + A.T) * 0.5
print("A is normal matrix: ||AA* - A*A|| =", np.linalg.norm(A.dot(A.T) - A.T.dot(A)))
b = np.random.randn(n)
# Hilbert matrix
# A = np.array([[1.0 / (i+j - 1) for i in range(1, n+1)] for j in range(1, n+1)])
# b = np.ones(n)
f = lambda x: 0.5 * x.dot(A.dot(x)) - b.dot(x)
grad_f = lambda x: A.dot(x) - b
x0 = np.zeros(n)
Explanation: Метод сопряжённых градиентов (Conjugate gradient method): гадкий утёнок
На прошлом семинаре...
Методы спуска
Направление убывания
Градиентный метод
Правила выбора шага
Теоремы сходимости
Эксперименты
Система линейных уравнений vs. задача безусловной минимизации
Рассмотрим задачу
$$
\min_{x \in \mathbb{R}^n} \frac{1}{2}x^{\top}Ax - b^{\top}x,
$$
где $A \in \mathbb{S}^n_{++}$.
Из необходимого условия экстремума имеем
$$
Ax^* = b
$$
Также обозначим $f'(x_k) = Ax_k - b = r_k$
Как решить систему $Ax = b$?
Прямые методы основаны на матричных разложениях:
Плотная матрица $A$: для размерностей не больше нескольких тысяч
Разреженная (sparse) матрица $A$: для размерностей порядка $10^4 - 10^5$
Итерационные методы: хороши во многих случаях, единственный подход для задач с размерностью $ > 10^6$
Немного истории...
M. Hestenes и E. Stiefel предложили метод сопряжённых градиентов для решения систем линейных уравнений в 1952 году как прямой метод.
Также долгое время считалось, что метод представляет только теоретический интерес поскольку
- метод сопряжённых градиентов не работает на логарифмической линейке
- метод сопряжённых градиентов имеет небольшое преимущество перед исключением Гаусса при вычислениях на калькуляторе
- для вычислений на "human computers" слишком много обменов данными
<img src="./human_computer.jpeg">
Метод сопряжённых градиентов необходимо рассматривать как итерационный метод, то есть останавливаться до точной сходимости!
Подробнее здесь
Метод сопряжённых направлений
В градиентном спуске направления убывания - анти-градиенты, но для функций с плохо обусловленным гессианом сходимость медленная.
Идея: двигаться вдоль направлений, которые гарантируют сходимость за $n$ шагов.
Определение. Множество ненулевых векторов ${p_0, \ldots, p_l}$ называется сопряжённым относительно матрицы $A \in \mathbb{S}^n_{++}$, если
$$
p^{\top}_iAp_j = 0, \qquad i \neq j
$$
Утверждение. Для любой $x_0 \in \mathbb{R}^n$ последовательность ${x_k}$, генерируемая методом сопряжённых направлений, сходится к решению системы $Ax = b$ максимум за $n$ шагов.
python
def ConjugateDirections(x0, A, b, p):
x = x0
r = A.dot(x) - b
for i in range(len(p)):
alpha = - (r.dot(p[i])) / (p[i].dot(A.dot(p[i])))
x = x + alpha * p[i]
r = A.dot(x) - b
return x
Примеры сопряжённых направлений
Собственные векторы матрицы $A$
Для любого набора из $n$ векторов можно провести аналог ортогонализации Грама-Шмидта и получить сопряжённые направления
Вопрос: что такое ортогонализация Грама-Шмидта? :)
Геометрическая интерпретация (Mathematics Stack Exchange)
<center><img src="./cg.png" ></center>
Метод сопряжённых градиентов
Идея: новое направление $p_k$ ищется в виде $p_k = -r_k + \beta_k p_{k-1}$, где $\beta_k$ выбирается, исходя из требования сопряжённости $p_k$ и $p_{k-1}$:
$$
\beta_k = \dfrac{p^{\top}{k-1}Ar_k}{p^{\top}{k-1}Ap^{\top}_{k-1}}
$$
Таким образом, для получения следующего сопряжённого направления $p_k$ необходимо хранить только сопряжённое направление $p_{k-1}$ и остаток $r_k$ с предыдущей итерации.
Вопрос: как находить размер шага $\alpha_k$?
Сопряжённость сопряжённых градиентов
Теорема
Пусть после $k$ итераций $x_k \neq x^*$. Тогда
$\langle r_k, r_i \rangle = 0, \; i = 1, \ldots k - 1$
$\mathtt{span}(r_0, \ldots, r_k) = \mathtt{span}(r_0, Ar_0, \ldots, A^kr_0)$
$\mathtt{span}(p_0, \ldots, p_k) = \mathtt{span}(r_0, Ar_0, \ldots, A^kr_0)$
$p_k^{\top}Ap_i = 0$, $i = 1,\ldots,k-1$
Теоремы сходимости
Теорема 1. Если матрица $A$ имеет только $r$ различных собственных значений, то метод сопряжённых градиентов cойдётся за $r$ итераций.
Теорема 2. Имеет место следующая оценка сходимости
$$
\| x_{k} - x^ \|_A \leq 2\left( \dfrac{\sqrt{\kappa(A)} - 1}{\sqrt{\kappa(A)} + 1} \right)^k \|x_0 - x^\|_A,
$$
где $\|x\|_A = x^{\top}Ax$ и $\kappa(A) = \frac{\lambda_1(A)}{\lambda_n(A)}$ - число обусловленности матрицы $A$, $\lambda_1(A) \geq ... \geq \lambda_n(A)$ - собственные значения матрицы $A$
Замечание: сравните коэффициент геометрической прогрессии с аналогом в градиентном спуске.
Интерпретации метода сопряжённых градиентов
Градиентный спуск в пространстве $y = Sx$, где $S = [p_0, \ldots, p_n]$, в котором матрица $A$ становится диагональной (или единичной в случае ортонормированности сопряжённых направлений)
Поиск оптимального решения в Крыловском подпространстве $\mathcal{K}_k(A) = {b, Ab, A^2b, \ldots A^{k-1}b}$
$$
x_k = \arg\min_{x \in \mathcal{K}_k} f(x)
$$
Однако естественный базис Крыловского пространства неортогональный и, более того, плохо обусловлен.
Упражнение Проверьте численно, насколько быстро растёт обусловленность матрицы из векторов ${b, Ab, ... }$
Поэтому его необходимо ортогонализовать, что и происходит в методе сопряжённых градиентов
Основное свойство
$$
A^{-1}b \in \mathcal{K}_n(A)
$$
Доказательство
Теорема Гамильтона-Кэли: $p(A) = 0$, где $p(\lambda) = \det(A - \lambda I)$
$p(A)b = A^nb + a_1A^{n-1}b + \ldots + a_{n-1}Ab + a_n b = 0$
$A^{-1}p(A)b = A^{n-1}b + a_1A^{n-2}b + \ldots + a_{n-1}b + a_nA^{-1}b = 0$
$A^{-1}b = -\frac{1}{a_n}(A^{n-1}b + a_1A^{n-2}b + \ldots + a_{n-1}b)$
Сходимость по функции и по аргументу
Решение: $x^* = A^{-1}b$
Минимум функции:
$$
f^ = \frac{1}{2}b^{\top}A^{-\top}AA^{-1}b - b^{\top}A^{-1}b = -\frac{1}{2}b^{\top}A^{-1}b = -\frac{1}{2}\|x^\|^2_A
$$
Оценка сходимости по функции:
$$
f(x) - f^ = \frac{1}{2}x^{\top}Ax - b^{\top}x + \frac{1}{2}\|x^\|_A^2 =\frac{1}{2}\|x\|_A^2 - x^{\top}Ax^ + \frac{1}{2}\|x^\|_A^2 = \frac{1}{2}\|x - x^*\|_A^2
$$
Доказательство сходимости
$x_k$ лежит в $\mathcal{K}_k$
$x_k = \sum\limits_{i=1}^k c_i A^{i-1}b = p(A)b$, где $p(x)$ некоторый полином степени не выше $k-1$
$x_k$ минимизирует $f$ на $\mathcal{K}_k$, отсюда
$$
2(f_k - f^) = \inf_{x \in \mathcal{K}_k} \|x - x^ \|^2_A = \inf_{\mathrm{deg}(p) < k} \|(p(A) - A^{-1})b\|^2_A
$$
Спектральное разложение $A = U\Lambda U^*$ даёт
$$
2(f_k - f^*) = \inf_{\mathrm{deg}(p) < k} \|(p(\Lambda) - \Lambda^{-1})d\|^2_{\Lambda} = \inf_{\mathrm{deg}(p) < k} \sum_{i=1}^n\frac{d_i^2 (\lambda_ip(\lambda_i) - 1)^2}{\lambda_i} = \inf_{\mathrm{deg}(q) \leq k, q(0) = 1} \sum_{i=1}^n\frac{d_i^2 q(\lambda_i)^2}{\lambda_i}
$$
Сведём задачу к поиску некоторого многочлена
$$
f_k - f^ \leq \left(\sum_{i=1}^n \frac{d_i^2}{2\lambda_i}\right) \inf_{\mathrm{deg}(q) \leq k, q(0) = 1}\left(\max_{i=1,\ldots,n} q(\lambda_i)^2 \right) = \frac{1}{2}\|x^\|^2_A \inf_{\mathrm{deg}(q) \leq k, q(0) = 1}\left(\max_{i=1,\ldots,n} q(\lambda_i)^2 \right)
$$
Пусть $A$ имеет $m$ различных собственных значений, тогда для
$$
r(y) = \frac{(-1)^m}{\lambda_1 \cdot \ldots \cdot \lambda_m}(y - \lambda_i)\cdot \ldots \cdot (y - \lambda_m)
$$
выполнено $\mathrm{deg}(r) = m$ и $r(0) = 1$
- Значение для оптимального полинома степени не выше $k$ оценим сверху значением для полинома $r$ степени $m$
$$
0 \leq f_k - f^ \leq \frac{1}{2}\|x^\|A^2 \max{i=1,\ldots,m} r(\lambda_i) = 0
$$
- Метод сопряжённых градиентов сошёлся за $m$ итераций
Улучшенная версия метода сопряжённых градиентов
На практике используются следующие формулы для шага $\alpha_k$ и коэффициента $\beta_{k}$:
$$
\alpha_k = \dfrac{r^{\top}k r_k}{p^{\top}{k}Ap_{k}} \qquad \beta_k = \dfrac{r^{\top}k r_k}{r^{\top}{k-1} r_{k-1}}
$$
Вопрос: чем они лучше базовой версии?
Псевдокод метода сопряжённых градиентов
python
def ConjugateGradientQuadratic(x0, A, b, eps):
r = A.dot(x0) - b
p = -r
while np.linalg.norm(r) > eps:
alpha = r.dot(r) / p.dot(A.dot(p))
x = x + alpha * p
r_next = r + alpha * A.dot(p)
beta = r_next.dot(r_next) / r.dot(r)
p = -r_next + beta * p
r = r_next
return x
Метод сопряжённых градиентов для неквадратичной функции
Идея: использовать градиенты $f'(x_k)$ неквадратичной функции вместо остатков $r_k$ и линейный поиск шага $\alpha_k$ вместо аналитического вычисления. Получим метод Флетчера-Ривса.
python
def ConjugateGradientFR(f, gradf, x0, eps):
x = x0
grad = gradf(x)
p = -grad
while np.linalg.norm(gradf(x)) > eps:
alpha = StepSearch(x, f, gradf, **kwargs)
x = x + alpha * p
grad_next = gradf(x)
beta = grad_next.dot(grad_next) / grad.dot(grad)
p = -grad_next + beta * p
grad = grad_next
if restart_condition:
p = -gradf(x)
return x
Теорема сходимости
Теорема. Пусть
- множество уровней $\mathcal{L}$ ограничено
- существует $\gamma > 0$: $\| f'(x) \|_2 \leq \gamma$ для $x \in \mathcal{L}$
Тогда
$$
\lim_{j \to \infty} \| f'(x_{k_j}) \|_2 = 0
$$
Перезапуск (restart)
Для ускорения метода сопряжённых градиентов используют технику перезапусков: удаление ранее накопленной истории и перезапуск метода с текущей точки, как будто это точка $x_0$
Существуют разные условия, сигнализирующие о том, что надо делать перезапуск, например
$k = n$
$\dfrac{|\langle f'(x_k), f'(x_{k-1}) \rangle |}{\| f'(x_k) \|_2^2} \geq \nu \approx 0.1$
Можно показать (см. Nocedal, Wright Numerical Optimization, Ch. 5, p. 125), что запуск метода Флетчера-Ривза без использования перезапусков на некоторых итерациях может приводить к крайне медленной сходимости!
Метод Полака-Рибьера и его модификации лишены подобного недостатка.
Комментарии
Замечательная методичка "An Introduction to the Conjugate Gradient Method Without the Agonizing Pain" размещена тут
Помимо метода Флетчера-Ривса существуют другие способы вычисления $\beta_k$: метод Полака-Рибьера, метод Хестенса-Штифеля...
Для метода сопряжённых градиентов требуется 4 вектора: каких?
Самой дорогой операцией является умножение матрицы на вектор
Эксперименты
Квадратичная целевая функция
End of explanation
USE_COLAB = False
%matplotlib inline
import matplotlib.pyplot as plt
if not USE_COLAB:
plt.rc("text", usetex=True)
plt.rc("font", family='serif')
if USE_COLAB:
!pip install git+https://github.com/amkatrutsa/liboptpy
import seaborn as sns
sns.set_context("talk")
eigs = np.linalg.eigvalsh(A)
plt.semilogy(np.unique(eigs))
plt.ylabel("Eigenvalues", fontsize=20)
plt.xticks(fontsize=18)
_ = plt.yticks(fontsize=18)
Explanation: Распределение собственных значений
End of explanation
import scipy.optimize as scopt
def callback(x, array):
array.append(x)
scopt_cg_array = []
scopt_cg_callback = lambda x: callback(x, scopt_cg_array)
x = scopt.minimize(f, x0, method="CG", jac=grad_f, callback=scopt_cg_callback)
x = x.x
print("||f'(x*)|| =", np.linalg.norm(A.dot(x) - b))
print("f* =", f(x))
Explanation: Правильный ответ
End of explanation
def ConjugateGradientQuadratic(x0, A, b, tol=1e-8, callback=None):
x = x0
r = A.dot(x0) - b
p = -r
while np.linalg.norm(r) > tol:
alpha = r.dot(r) / p.dot(A.dot(p))
x = x + alpha * p
if callback is not None:
callback(x)
r_next = r + alpha * A.dot(p)
beta = r_next.dot(r_next) / r.dot(r)
p = -r_next + beta * p
r = r_next
return x
import liboptpy.unconstr_solvers as methods
import liboptpy.step_size as ss
print("\t CG quadratic")
cg_quad = methods.fo.ConjugateGradientQuad(A, b)
x_cg = cg_quad.solve(x0, tol=1e-7, disp=True)
print("\t Gradient Descent")
gd = methods.fo.GradientDescent(f, grad_f, ss.ExactLineSearch4Quad(A, b))
x_gd = gd.solve(x0, tol=1e-7, disp=True)
print("Condition number of A =", abs(max(eigs)) / abs(min(eigs)))
Explanation: Реализация метода сопряжённых градиентов
End of explanation
plt.figure(figsize=(8,6))
plt.semilogy([np.linalg.norm(grad_f(x)) for x in cg_quad.get_convergence()], label=r"$\|f'(x_k)\|^{CG}_2$", linewidth=2)
plt.semilogy([np.linalg.norm(grad_f(x)) for x in scopt_cg_array[:50]], label=r"$\|f'(x_k)\|^{CG_{PR}}_2$", linewidth=2)
plt.semilogy([np.linalg.norm(grad_f(x)) for x in gd.get_convergence()], label=r"$\|f'(x_k)\|^{G}_2$", linewidth=2)
plt.legend(loc="best", fontsize=20)
plt.xlabel(r"Iteration number, $k$", fontsize=20)
plt.ylabel("Convergence rate", fontsize=20)
plt.xticks(fontsize=18)
_ = plt.yticks(fontsize=18)
print([np.linalg.norm(grad_f(x)) for x in cg_quad.get_convergence()])
plt.figure(figsize=(8,6))
plt.plot([f(x) for x in cg_quad.get_convergence()], label=r"$f(x^{CG}_k)$", linewidth=2)
plt.plot([f(x) for x in scopt_cg_array], label=r"$f(x^{CG_{PR}}_k)$", linewidth=2)
plt.plot([f(x) for x in gd.get_convergence()], label=r"$f(x^{G}_k)$", linewidth=2)
plt.legend(loc="best", fontsize=20)
plt.xlabel(r"Iteration number, $k$", fontsize=20)
plt.ylabel("Function value", fontsize=20)
plt.xticks(fontsize=18)
_ = plt.yticks(fontsize=18)
Explanation: График сходимости
End of explanation
import numpy as np
import sklearn.datasets as skldata
import scipy.special as scspec
n = 300
m = 1000
X, y = skldata.make_classification(n_classes=2, n_features=n, n_samples=m, n_informative=n//3)
C = 1
def f(w):
return np.linalg.norm(w)**2 / 2 + C * np.mean(np.logaddexp(np.zeros(X.shape[0]), -y * X.dot(w)))
def grad_f(w):
denom = scspec.expit(-y * X.dot(w))
return w - C * X.T.dot(y * denom) / X.shape[0]
# f = lambda x: -np.sum(np.log(1 - A.T.dot(x))) - np.sum(np.log(1 - x*x))
# grad_f = lambda x: np.sum(A.dot(np.diagflat(1 / (1 - A.T.dot(x)))), axis=1) + 2 * x / (1 - np.power(x, 2))
x0 = np.zeros(n)
print("Initial function value = {}".format(f(x0)))
print("Initial gradient norm = {}".format(np.linalg.norm(grad_f(x0))))
Explanation: Неквадратичная функция
End of explanation
def ConjugateGradientFR(f, gradf, x0, num_iter=100, tol=1e-8, callback=None, restart=False):
x = x0
grad = gradf(x)
p = -grad
it = 0
while np.linalg.norm(gradf(x)) > tol and it < num_iter:
alpha = utils.backtracking(x, p, method="Wolfe", beta1=0.1, beta2=0.4, rho=0.5, f=f, grad_f=gradf)
if alpha < 1e-18:
break
x = x + alpha * p
if callback is not None:
callback(x)
grad_next = gradf(x)
beta = grad_next.dot(grad_next) / grad.dot(grad)
p = -grad_next + beta * p
grad = grad_next.copy()
it += 1
if restart and it % restart == 0:
grad = gradf(x)
p = -grad
return x
Explanation: Реализация метода Флетчера-Ривса
End of explanation
import scipy.optimize as scopt
import liboptpy.restarts as restarts
n_restart = 60
tol = 1e-5
max_iter = 600
scopt_cg_array = []
scopt_cg_callback = lambda x: callback(x, scopt_cg_array)
x = scopt.minimize(f, x0, tol=tol, method="CG", jac=grad_f, callback=scopt_cg_callback, options={"maxiter": max_iter})
x = x.x
print("\t CG by Polak-Rebiere")
print("Norm of garient = {}".format(np.linalg.norm(grad_f(x))))
print("Function value = {}".format(f(x)))
print("\t CG by Fletcher-Reeves")
cg_fr = methods.fo.ConjugateGradientFR(f, grad_f, ss.Backtracking("Wolfe", rho=0.9, beta1=0.1, beta2=0.4, init_alpha=1.))
x = cg_fr.solve(x0, tol=tol, max_iter=max_iter, disp=True)
print("\t CG by Fletcher-Reeves with restart n")
cg_fr_rest = methods.fo.ConjugateGradientFR(f, grad_f, ss.Backtracking("Wolfe", rho=0.9, beta1=0.1, beta2=0.4,
init_alpha=1.), restarts.Restart(n // n_restart))
x = cg_fr_rest.solve(x0, tol=tol, max_iter=max_iter, disp=True)
print("\t Gradient Descent")
gd = methods.fo.GradientDescent(f, grad_f, ss.Backtracking("Wolfe", rho=0.9, beta1=0.1, beta2=0.4, init_alpha=1.))
x = gd.solve(x0, max_iter=max_iter, tol=tol, disp=True)
plt.figure(figsize=(8, 6))
plt.semilogy([np.linalg.norm(grad_f(x)) for x in cg_fr.get_convergence()], label=r"$\|f'(x_k)\|^{CG_{FR}}_2$ no restart", linewidth=2)
plt.semilogy([np.linalg.norm(grad_f(x)) for x in cg_fr_rest.get_convergence()], label=r"$\|f'(x_k)\|^{CG_{FR}}_2$ restart", linewidth=2)
plt.semilogy([np.linalg.norm(grad_f(x)) for x in scopt_cg_array], label=r"$\|f'(x_k)\|^{CG_{PR}}_2$", linewidth=2)
plt.semilogy([np.linalg.norm(grad_f(x)) for x in gd.get_convergence()], label=r"$\|f'(x_k)\|^{G}_2$", linewidth=2)
plt.legend(loc="best", fontsize=16)
plt.xlabel(r"Iteration number, $k$", fontsize=20)
plt.ylabel("Convergence rate", fontsize=20)
plt.xticks(fontsize=18)
_ = plt.yticks(fontsize=18)
Explanation: График сходимости
End of explanation
%timeit scopt.minimize(f, x0, method="CG", tol=tol, jac=grad_f, options={"maxiter": max_iter})
%timeit cg_fr.solve(x0, tol=tol, max_iter=max_iter)
%timeit cg_fr_rest.solve(x0, tol=tol, max_iter=max_iter)
%timeit gd.solve(x0, tol=tol, max_iter=max_iter)
Explanation: Время выполнения
End of explanation |
3,491 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
# Getting Started with gensim
This section introduces the basic concepts and terms needed to understand and use gensim and provides a simple usage example.
Core Concepts and Simple Example
At a very high-level, gensim is a tool for discovering the semantic structure of documents by examining the patterns of words (or higher-level structures such as entire sentences or documents). gensim accomplishes this by taking a corpus, a collection of text documents, and producing a vector representation of the text in the corpus. The vector representation can then be used to train a model, which is an algorithms to create different representations of the data, which are usually more semantic. These three concepts are key to understanding how gensim works so let's take a moment to explain what each of them means. At the same time, we'll work through a simple example that illustrates each of them.
Corpus
A corpus is a collection of digital documents. This collection is the input to gensim from which it will infer the structure of the documents, their topics, etc. The latent structure inferred from the corpus can later be used to assign topics to new documents which were not present in the training corpus. For this reason, we also refer to this collection as the training corpus. No human intervention (such as tagging the documents by hand) is required - the topic classification is unsupervised.
For our corpus, we'll use a list of 9 strings, each consisting of only a single sentence.
Step1: This is a particularly small example of a corpus for illustration purposes. Another example could be a list of all the plays written by Shakespeare, list of all wikipedia articles, or all tweets by a particular person of interest.
After collecting our corpus, there are typically a number of preprocessing steps we want to undertake. We'll keep it simple and just remove some commonly used English words (such as 'the') and words that occur only once in the corpus. In the process of doing so, we'll tokenise our data. Tokenization breaks up the documents into words (in this case using space as a delimiter).
Step2: Before proceeding, we want to associate each word in the corpus with a unique integer ID. We can do this using the gensim.corpora.Dictionary class. This dictionary defines the vocabulary of all words that our processing knows about.
Step3: Because our corpus is small, there is only 12 different tokens in this Dictionary. For larger corpuses, dictionaries that contains hundreds of thousands of tokens are quite common.
Vector
To infer the latent structure in our corpus we need a way to represent documents that we can manipulate mathematically. One approach is to represent each document as a vector. There are various approachs for creating a vector representation of a document but a simple example is the bag-of-words model. Under the bag-of-words model each document is represented by a vector containing the frequency counts of each word in the dictionary. For example, given a dictionary containing the words ['coffee', 'milk', 'sugar', 'spoon'] a document consisting of the string "coffee milk coffee" could be represented by the vector [2, 1, 0, 0] where the entries of the vector are (in order) the occurrences of "coffee", "milk", "sugar" and "spoon" in the document. The length of the vector is the number of entries in the dictionary. One of the main properties of the bag-of-words model is that it completely ignores the order of the tokens in the document that is encoded, which is where the name bag-of-words comes from.
Our processed corpus has 12 unique words in it, which means that each document will be represented by a 12-dimensional vector under the bag-of-words model. We can use the dictionary to turn tokenized documents into these 12-dimensional vectors. We can see what these IDs correspond to
Step4: For example, suppose we wanted to vectorize the phrase "Human computer interaction" (note that this phrase was not in our original corpus). We can create the bag-of-word representation for a document using the doc2bow method of the dictionary, which returns a sparse representation of the word counts
Step5: The first entry in each tuple corresponds to the ID of the token in the dictionary, the second corresponds to the count of this token.
Note that "interaction" did not occur in the original corpus and so it was not included in the vectorization. Also note that this vector only contains entries for words that actually appeared in the document. Because any given document will only contain a few words out of the many words in the dictionary, words that do not appear in the vectorization are represented as implicitly zero as a space saving measure.
We can convert our entire original corpus to a list of vectors
Step6: Note that while this list lives entirely in memory, while in most applications you will want a more scalable solution. Luckily, gensim allows you to use any iterator that returns a single document vector at a time. See the documentation for more details.
Model
Now that we have vectorized our corpus we can begin to transform it using models. We use model as an abstract term referring to a transformation from one document representation to another. In gensim documents are represented as vectors so a model can be thought of as a transformation between two vector spaces. The details of this transformation are learned from the training corpus.
One simple example of a model is tf-idf. The tf-idf model transforms vectors from the bag-of-words representation to a vector space where the frequency counts are weighted according to the relative rarity of each word in the corpus.
Here's a simple example. Let's initialize the tf-idf model, training it on our corpus and transforming the string "system minors" | Python Code:
raw_corpus = ["Human machine interface for lab abc computer applications",
"A survey of user opinion of computer system response time",
"The EPS user interface management system",
"System and human system engineering testing of EPS",
"Relation of user perceived response time to error measurement",
"The generation of random binary unordered trees",
"The intersection graph of paths in trees",
"Graph minors IV Widths of trees and well quasi ordering",
"Graph minors A survey"]
Explanation: # Getting Started with gensim
This section introduces the basic concepts and terms needed to understand and use gensim and provides a simple usage example.
Core Concepts and Simple Example
At a very high-level, gensim is a tool for discovering the semantic structure of documents by examining the patterns of words (or higher-level structures such as entire sentences or documents). gensim accomplishes this by taking a corpus, a collection of text documents, and producing a vector representation of the text in the corpus. The vector representation can then be used to train a model, which is an algorithms to create different representations of the data, which are usually more semantic. These three concepts are key to understanding how gensim works so let's take a moment to explain what each of them means. At the same time, we'll work through a simple example that illustrates each of them.
Corpus
A corpus is a collection of digital documents. This collection is the input to gensim from which it will infer the structure of the documents, their topics, etc. The latent structure inferred from the corpus can later be used to assign topics to new documents which were not present in the training corpus. For this reason, we also refer to this collection as the training corpus. No human intervention (such as tagging the documents by hand) is required - the topic classification is unsupervised.
For our corpus, we'll use a list of 9 strings, each consisting of only a single sentence.
End of explanation
# Create a set of frequent words
stoplist = set('for a of the and to in'.split(' '))
# Lowercase each document, split it by white space and filter out stopwords
texts = [[word for word in document.lower().split() if word not in stoplist]
for document in raw_corpus]
# Count word frequencies
from collections import defaultdict
frequency = defaultdict(int)
for text in texts:
for token in text:
frequency[token] += 1
# Only keep words that appear more than once
processed_corpus = [[token for token in text if frequency[token] > 1] for text in texts]
processed_corpus
Explanation: This is a particularly small example of a corpus for illustration purposes. Another example could be a list of all the plays written by Shakespeare, list of all wikipedia articles, or all tweets by a particular person of interest.
After collecting our corpus, there are typically a number of preprocessing steps we want to undertake. We'll keep it simple and just remove some commonly used English words (such as 'the') and words that occur only once in the corpus. In the process of doing so, we'll tokenise our data. Tokenization breaks up the documents into words (in this case using space as a delimiter).
End of explanation
from gensim import corpora
dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)
Explanation: Before proceeding, we want to associate each word in the corpus with a unique integer ID. We can do this using the gensim.corpora.Dictionary class. This dictionary defines the vocabulary of all words that our processing knows about.
End of explanation
print(dictionary.token2id)
Explanation: Because our corpus is small, there is only 12 different tokens in this Dictionary. For larger corpuses, dictionaries that contains hundreds of thousands of tokens are quite common.
Vector
To infer the latent structure in our corpus we need a way to represent documents that we can manipulate mathematically. One approach is to represent each document as a vector. There are various approachs for creating a vector representation of a document but a simple example is the bag-of-words model. Under the bag-of-words model each document is represented by a vector containing the frequency counts of each word in the dictionary. For example, given a dictionary containing the words ['coffee', 'milk', 'sugar', 'spoon'] a document consisting of the string "coffee milk coffee" could be represented by the vector [2, 1, 0, 0] where the entries of the vector are (in order) the occurrences of "coffee", "milk", "sugar" and "spoon" in the document. The length of the vector is the number of entries in the dictionary. One of the main properties of the bag-of-words model is that it completely ignores the order of the tokens in the document that is encoded, which is where the name bag-of-words comes from.
Our processed corpus has 12 unique words in it, which means that each document will be represented by a 12-dimensional vector under the bag-of-words model. We can use the dictionary to turn tokenized documents into these 12-dimensional vectors. We can see what these IDs correspond to:
End of explanation
new_doc = "Human computer interaction"
new_vec = dictionary.doc2bow(new_doc.lower().split())
new_vec
Explanation: For example, suppose we wanted to vectorize the phrase "Human computer interaction" (note that this phrase was not in our original corpus). We can create the bag-of-word representation for a document using the doc2bow method of the dictionary, which returns a sparse representation of the word counts:
End of explanation
bow_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
bow_corpus
Explanation: The first entry in each tuple corresponds to the ID of the token in the dictionary, the second corresponds to the count of this token.
Note that "interaction" did not occur in the original corpus and so it was not included in the vectorization. Also note that this vector only contains entries for words that actually appeared in the document. Because any given document will only contain a few words out of the many words in the dictionary, words that do not appear in the vectorization are represented as implicitly zero as a space saving measure.
We can convert our entire original corpus to a list of vectors:
End of explanation
from gensim import models
# train the model
tfidf = models.TfidfModel(bow_corpus)
# transform the "system minors" sting
tfidf[dictionary.doc2bow("system minors".lower().split())]
Explanation: Note that while this list lives entirely in memory, while in most applications you will want a more scalable solution. Luckily, gensim allows you to use any iterator that returns a single document vector at a time. See the documentation for more details.
Model
Now that we have vectorized our corpus we can begin to transform it using models. We use model as an abstract term referring to a transformation from one document representation to another. In gensim documents are represented as vectors so a model can be thought of as a transformation between two vector spaces. The details of this transformation are learned from the training corpus.
One simple example of a model is tf-idf. The tf-idf model transforms vectors from the bag-of-words representation to a vector space where the frequency counts are weighted according to the relative rarity of each word in the corpus.
Here's a simple example. Let's initialize the tf-idf model, training it on our corpus and transforming the string "system minors":
End of explanation |
3,492 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
<a href='http
Step1: Build a vocabulary
The goal here is to build a numerical array from all the words that appear in every document. Later we'll create instances (vectors) for each individual document.
Step2: Even though 2.txt has 15 words, only 7 new words were added to the dictionary.
Feature Extraction
Now that we've encapsulated our "entire language" in a dictionary, let's perform feature extraction on each of our original documents
Step3: <font color=green>We can see that most of the words in 1.txt appear only once, although "cats" appears twice.</font>
Step4: By comparing the vectors we see that some words are common to both, some appear only in 1.txt, others only in 2.txt. Extending this logic to tens of thousands of documents, we would see the vocabulary dictionary grow to hundreds of thousands of words. Vectors would contain mostly zero values, making them sparse matrices.
Bag of Words and Tf-idf
In the above examples, each vector can be considered a bag of words. By itself these may not be helpful until we consider term frequencies, or how often individual words appear in documents. A simple way to calculate term frequencies is to divide the number of occurrences of a word by the total number of words in the document. In this way, the number of times a word appears in large documents can be compared to that of smaller documents.
However, it may be hard to differentiate documents based on term frequency if a word shows up in a majority of documents. To handle this we also consider inverse document frequency, which is the total number of documents divided by the number of documents that contain the word. In practice we convert this value to a logarithmic scale, as described here.
Together these terms become tf-idf.
Stop Words and Word Stems
Some words like "the" and "and" appear so frequently, and in so many documents, that we needn't bother counting them. Also, it may make sense to only record the root of a word, say cat in place of both cat and cats. This will shrink our vocab array and improve performance.
Tokenization and Tagging
When we created our vectors the first thing we did was split the incoming text on whitespace with .split(). This was a crude form of tokenization - that is, dividing a document into individual words. In this simple example we didn't worry about punctuation or different parts of speech. In the real world we rely on some fairly sophisticated morphology to parse text appropriately.
Once the text is divided, we can go back and tag our tokens with information about parts of speech, grammatical dependencies, etc. This adds more dimensions to our data and enables a deeper understanding of the context of specific documents. For this reason, vectors become high dimensional sparse matrices.
<div class="alert alert-info" style="margin
Step5: Check for missing values
Step6: Take a quick look at the ham and spam label column
Step7: <font color=green>4825 out of 5572 messages, or 86.6%, are ham. This means that any text classification model we create has to perform better than 86.6% to beat random chance.</font>
Split the data into train & test sets
Step8: Scikit-learn's CountVectorizer
Text preprocessing, tokenizing and the ability to filter out stopwords are all included in CountVectorizer, which builds a dictionary of features and transforms documents to feature vectors.
Step9: <font color=green>This shows that our training set is comprised of 3733 documents, and 7082 features.</font>
Transform Counts to Frequencies with Tf-idf
While counting words is helpful, longer documents will have higher average count values than shorter documents, even though they might talk about the same topics.
To avoid this we can simply divide the number of occurrences of each word in a document by the total number of words in the document
Step10: Note
Step11: Train a Classifier
Here we'll introduce an SVM classifier that's similar to SVC, called LinearSVC. LinearSVC handles sparse input better, and scales well to large numbers of samples.
Step12: <font color=green>Earlier we named our SVC classifier svc_model. Here we're using the more generic name clf (for classifier).</font>
Build a Pipeline
Remember that only our training set has been vectorized into a full vocabulary. In order to perform an analysis on our test set we'll have to submit it to the same procedures. Fortunately scikit-learn offers a Pipeline class that behaves like a compound classifier.
Step13: Test the classifier and display results | Python Code:
%%writefile 1.txt
This is a story about cats
our feline pets
Cats are furry animals
%%writefile 2.txt
This story is about surfing
Catching waves is fun
Surfing is a popular water sport
Explanation: <a href='http://www.pieriandata.com'> <img src='../Pierian_Data_Logo.png' /></a>
This unit is divided into two sections:
* First, we'll find out what what is necessary to build an NLP system that can turn a body of text into a numerical array of features.
* Next we'll show how to perform these steps using real tools.
Building a Natural Language Processor From Scratch
In this section we'll use basic Python to build a rudimentary NLP system. We'll build a corpus of documents (two small text files), create a vocabulary from all the words in both documents, and then demonstrate a Bag of Words technique to extract features from each document.<br>
<div class="alert alert-info" style="margin: 20px">**This first section is for illustration only!**
<br>Don't bother memorizing the code - we'd never do this in real life.</div>
Start with some documents:
For simplicity we won't use any punctuation.
End of explanation
vocab = {}
i = 1
with open('1.txt') as f:
x = f.read().lower().split()
for word in x:
if word in vocab:
continue
else:
vocab[word]=i
i+=1
print(vocab)
with open('2.txt') as f:
x = f.read().lower().split()
for word in x:
if word in vocab:
continue
else:
vocab[word]=i
i+=1
print(vocab)
Explanation: Build a vocabulary
The goal here is to build a numerical array from all the words that appear in every document. Later we'll create instances (vectors) for each individual document.
End of explanation
# Create an empty vector with space for each word in the vocabulary:
one = ['1.txt']+[0]*len(vocab)
one
# map the frequencies of each word in 1.txt to our vector:
with open('1.txt') as f:
x = f.read().lower().split()
for word in x:
one[vocab[word]]+=1
one
Explanation: Even though 2.txt has 15 words, only 7 new words were added to the dictionary.
Feature Extraction
Now that we've encapsulated our "entire language" in a dictionary, let's perform feature extraction on each of our original documents:
End of explanation
# Do the same for the second document:
two = ['2.txt']+[0]*len(vocab)
with open('2.txt') as f:
x = f.read().lower().split()
for word in x:
two[vocab[word]]+=1
# Compare the two vectors:
print(f'{one}\n{two}')
Explanation: <font color=green>We can see that most of the words in 1.txt appear only once, although "cats" appears twice.</font>
End of explanation
# Perform imports and load the dataset:
import numpy as np
import pandas as pd
df = pd.read_csv('../TextFiles/smsspamcollection.tsv', sep='\t')
df.head()
Explanation: By comparing the vectors we see that some words are common to both, some appear only in 1.txt, others only in 2.txt. Extending this logic to tens of thousands of documents, we would see the vocabulary dictionary grow to hundreds of thousands of words. Vectors would contain mostly zero values, making them sparse matrices.
Bag of Words and Tf-idf
In the above examples, each vector can be considered a bag of words. By itself these may not be helpful until we consider term frequencies, or how often individual words appear in documents. A simple way to calculate term frequencies is to divide the number of occurrences of a word by the total number of words in the document. In this way, the number of times a word appears in large documents can be compared to that of smaller documents.
However, it may be hard to differentiate documents based on term frequency if a word shows up in a majority of documents. To handle this we also consider inverse document frequency, which is the total number of documents divided by the number of documents that contain the word. In practice we convert this value to a logarithmic scale, as described here.
Together these terms become tf-idf.
Stop Words and Word Stems
Some words like "the" and "and" appear so frequently, and in so many documents, that we needn't bother counting them. Also, it may make sense to only record the root of a word, say cat in place of both cat and cats. This will shrink our vocab array and improve performance.
Tokenization and Tagging
When we created our vectors the first thing we did was split the incoming text on whitespace with .split(). This was a crude form of tokenization - that is, dividing a document into individual words. In this simple example we didn't worry about punctuation or different parts of speech. In the real world we rely on some fairly sophisticated morphology to parse text appropriately.
Once the text is divided, we can go back and tag our tokens with information about parts of speech, grammatical dependencies, etc. This adds more dimensions to our data and enables a deeper understanding of the context of specific documents. For this reason, vectors become high dimensional sparse matrices.
<div class="alert alert-info" style="margin: 20px">**That's the end of the first section.**
<br>In the next section we'll use scikit-learn to perform a real-life analysis.</div>
Feature Extraction from Text
In the Scikit-learn Primer lecture we applied a simple SVC classification model to the SMSSpamCollection dataset. We tried to predict the ham/spam label based on message length and punctuation counts. In this section we'll actually look at the text of each message and try to perform a classification based on content. We'll take advantage of some of scikit-learn's feature extraction tools.
Load a dataset
End of explanation
df.isnull().sum()
Explanation: Check for missing values:
Always a good practice.
End of explanation
df['label'].value_counts()
Explanation: Take a quick look at the ham and spam label column:
End of explanation
from sklearn.model_selection import train_test_split
X = df['message'] # this time we want to look at the text
y = df['label']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
Explanation: <font color=green>4825 out of 5572 messages, or 86.6%, are ham. This means that any text classification model we create has to perform better than 86.6% to beat random chance.</font>
Split the data into train & test sets:
End of explanation
from sklearn.feature_extraction.text import CountVectorizer
count_vect = CountVectorizer()
X_train_counts = count_vect.fit_transform(X_train)
X_train_counts.shape
Explanation: Scikit-learn's CountVectorizer
Text preprocessing, tokenizing and the ability to filter out stopwords are all included in CountVectorizer, which builds a dictionary of features and transforms documents to feature vectors.
End of explanation
from sklearn.feature_extraction.text import TfidfTransformer
tfidf_transformer = TfidfTransformer()
X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)
X_train_tfidf.shape
Explanation: <font color=green>This shows that our training set is comprised of 3733 documents, and 7082 features.</font>
Transform Counts to Frequencies with Tf-idf
While counting words is helpful, longer documents will have higher average count values than shorter documents, even though they might talk about the same topics.
To avoid this we can simply divide the number of occurrences of each word in a document by the total number of words in the document: these new features are called tf for Term Frequencies.
Another refinement on top of tf is to downscale weights for words that occur in many documents in the corpus and are therefore less informative than those that occur only in a smaller portion of the corpus.
This downscaling is called tf–idf for “Term Frequency times Inverse Document Frequency”.
Both tf and tf–idf can be computed as follows using TfidfTransformer:
End of explanation
from sklearn.feature_extraction.text import TfidfVectorizer
vectorizer = TfidfVectorizer()
X_train_tfidf = vectorizer.fit_transform(X_train) # remember to use the original X_train set
X_train_tfidf.shape
Explanation: Note: the fit_transform() method actually performs two operations: it fits an estimator to the data and then transforms our count-matrix to a tf-idf representation.
Combine Steps with TfidVectorizer
In the future, we can combine the CountVectorizer and TfidTransformer steps into one using TfidVectorizer:
End of explanation
from sklearn.svm import LinearSVC
clf = LinearSVC()
clf.fit(X_train_tfidf,y_train)
Explanation: Train a Classifier
Here we'll introduce an SVM classifier that's similar to SVC, called LinearSVC. LinearSVC handles sparse input better, and scales well to large numbers of samples.
End of explanation
from sklearn.pipeline import Pipeline
# from sklearn.feature_extraction.text import TfidfVectorizer
# from sklearn.svm import LinearSVC
text_clf = Pipeline([('tfidf', TfidfVectorizer()),
('clf', LinearSVC()),
])
# Feed the training data through the pipeline
text_clf.fit(X_train, y_train)
Explanation: <font color=green>Earlier we named our SVC classifier svc_model. Here we're using the more generic name clf (for classifier).</font>
Build a Pipeline
Remember that only our training set has been vectorized into a full vocabulary. In order to perform an analysis on our test set we'll have to submit it to the same procedures. Fortunately scikit-learn offers a Pipeline class that behaves like a compound classifier.
End of explanation
# Form a prediction set
predictions = text_clf.predict(X_test)
# Report the confusion matrix
from sklearn import metrics
print(metrics.confusion_matrix(y_test,predictions))
# Print a classification report
print(metrics.classification_report(y_test,predictions))
# Print the overall accuracy
print(metrics.accuracy_score(y_test,predictions))
Explanation: Test the classifier and display results
End of explanation |
3,493 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Feedforward Network
一樣有輸入 x, 輸出 y。 但是中間預測、計算的樣子有點不同。
<img src="https
Step1: 任務：計算最後的猜測機率 $q$
設定：輸入 4 維， 輸出 3 維， 隱藏層 6 維
* 設定一些權重 $A,b,C,d$ (隨意自行填入，或者用 np.random.randint(-2,3, size=...))
* 設定輸入 $x$ (隨意自行填入，或者用 np.random.randint(-2,3, size=...))
* 自行定義 relu, sigmoid 函數 (Hint
Step2: 練習
設計一個網路
Step3: 練習
設計一個網路來判斷井字棋是否有連成直線(只需要判斷其中一方即可) | Python Code:
# 參考答案
%run solutions/ff_oneline.py
Explanation: Feedforward Network
一樣有輸入 x, 輸出 y。 但是中間預測、計算的樣子有點不同。
<img src="https://upload.wikimedia.org/wikipedia/en/5/54/Feed_forward_neural_net.gif" />
模型是這樣的
一樣考慮輸入是四維向量，輸出有 3 個類別。
我們的輸入 $x=\begin{pmatrix} x_0 \ x_1 \ x_2 \ x_3 \end{pmatrix} $ 是一個向量，我們看成 column vector 好了
第 0 層
而 Weight: $
W^{(0)} = \begin{pmatrix} W^{(0)}0 \ W^{(0)}_1 \ W^{(0)}_2 \ W^{(0)}_3 \ W^{(0)}_4 \ W^{(0)}_5 \end{pmatrix} =
\begin{pmatrix}
W^{(0)}{0,0} & W^{(0)}{0,1} & W^{(0)}{0,2} & W^{(0)}{0,3}\
W^{(0)}{0,0} & W^{(0)}{0,1} & W^{(0)}{0,2} & W^{(0)}{0,3}\
W^{(0)}{0,0} & W^{(0)}{0,1} & W^{(0)}{0,2} & W^{(0)}{0,3}\
W^{(0)}{0,0} & W^{(0)}{0,1} & W^{(0)}{0,2} & W^{(0)}{0,3}\
W^{(0)}{0,0} & W^{(0)}{0,1} & W^{(0)}{0,2} & W^{(0)}{0,3}\
W^{(0)}{0,0} & W^{(0)}{0,1} & W^{(0)}{0,2} & W^{(0)}_{0,3}
\end{pmatrix} $
Bias: $b^{(0)}=\begin{pmatrix} b^{(0)}_0 \ b^{(0)}_1 \ b^{(0)}_2 \ b^{(0)}_3 \ b^{(0)}_4 \ b^{(0)}_5 \end{pmatrix} $
我們先計算"線性輸出" $ c^{(0)} = \begin{pmatrix} c^{(0)}_0 \ c^{(0)}_1 \ c^{(0)}_2 \ c^{(0)}_3 \ c^{(0)}_4 \ c^{(0)}_5 \end{pmatrix} = W^{(0)}x+b^{(0)} =
\begin{pmatrix} W^{(0)}_0 x + b^{(0)}_0 \ W^{(0)}_1 x + b^{(0)}_1 \ W^{(0)}_2 x + b^{(0)}_2 \
W^{(0)}_3 x + b^{(0)}_3 \ W^{(0)}_4 x + b^{(0)}_4 \ W^{(0)}_5 x + b^{(0)}_5 \end{pmatrix} $，
然後再將結果逐項對一個非線性的函數 $f$ 最後得到一個向量。
$d^{(0)} = \begin{pmatrix} d^{(0)}_0 \ d^{(0)}_1 \ d^{(0)}_2 \ d^{(0)}_3 \ d^{(0)}_4 \ d^{(0)}_5 \end{pmatrix}
= f({W x + b}) = \begin{pmatrix} f(c^{(0)}_0) \ f(c^{(0)}_1) \ f(c^{(0)}_2) \ f(c^{(0)}_3) \ f(c^{(0)}_4) \ f(c^{(0)}_5) \end{pmatrix} $
這裡的 $f$ 常常會用 sigmoid , tanh，或者 ReLU ( https://en.wikipedia.org/wiki/Activation_function )。
第 1 層
這裡接到輸出，其實和 softmax regression 一樣。
只是輸入變成 $d^{(0)}, Weight 和 Bias 現在叫做 W^{(1)} 和 b^{(1)}
因為維度改變，現在 W^{(1)} 是 3x6 的矩陣。 後面接到的輸出都一樣。
所以線性輸出
$ c^{(1)} = W^{(1)} d^{(0)} + b^{(1)} $
$ d^{(1)} = e^{c^{(1)}} $
當輸入為 x, 最後的 softmax 預測類別是 i 的機率為
$q_i = Predict_{W^{(0)}, W^{(1)}, b^{(0)}, b^{(1)}}(Y=i|x) = \frac {d^{(1)}_i} {\sum_j d^{(1)}_j}$
合起來看，就是 $q = \frac {d^{(1)}} {\sum_j d^{(1)}_j}$
問題
我們簡化一下算式，如果 $W^{(0)}, W^{(1)}, b^{(0)}, b^{(1)}$ 設定為 $A, b, C, d$ (C, d 與前面無關)，請簡化成為一個算式。
可以利用 softmax function 的符號
$\sigma (\mathbf {z} ){j}={\frac {e^{z{j}}}{\sum k e^{z{k}}}}$
End of explanation
# 請在這裡計算
np.random.seed(1234)
# 參考答案，設定權重
%run -i solutions/ff_init_variables.py
display(A)
display(b)
display(C)
display(d)
display(x)
# 參考答案 定義 relu, sigmoid 及計算 z
%run -i solutions/ff_compute_z.py
display(z_relu)
display(z_sigmoid)
# 參考答案 定義 softmax 及計算 q
%run -i solutions/ff_compute_q.py
display(q_relu)
display(q_sigmoid)
Explanation: 任務：計算最後的猜測機率 $q$
設定：輸入 4 維， 輸出 3 維， 隱藏層 6 維
* 設定一些權重 $A,b,C,d$ (隨意自行填入，或者用 np.random.randint(-2,3, size=...))
* 設定輸入 $x$ (隨意自行填入，或者用 np.random.randint(-2,3, size=...))
* 自行定義 relu, sigmoid 函數 (Hint: np.maximum)
* 算出隱藏層 $z$
* 自行定義 softmax
* 算出最後的 q
End of explanation
# Hint 下面產生數字 i 的 2 進位向量
i = 13
x = Vector(i%2, (i>>1)%2, (i>>2)%2, (i>>3)%2)
x
# 請在這裡計算
# 參考解答
%run -i solutions/ff_mod3.py
Explanation: 練習
設計一個網路:
* 輸入是二進位 0 ~ 15
* 輸出依照對於 3 的餘數分成三類
End of explanation
# 請在這裡計算
#參考答案
%run -i solutions/ff_tic_tac_toe.py
# 測試你的答案
def my_result(x):
# return 0 means no, 1 means yes
return (C@relu(A@x+b)+d).argmax()
# or sigmoid based
# return (C@relu(A@x+b)+d) > 0
def truth(x):
x = x.reshape(3,3)
return (x.all(axis=0).any() or
x.all(axis=1).any() or
x.diagonal().all() or
x[::-1].diagonal().all())
for i in range(512):
x = np.array([[(i>>j)&1] for j in range(9)])
assert my_result(x) == truth(x)
print("test passed")
Explanation: 練習
設計一個網路來判斷井字棋是否有連成直線(只需要判斷其中一方即可):
* 輸入是 9 維向量，0 代表空格，1 代表有下子
* 輸出是二維(softmax)或一維(sigmoid)皆可，用來代表 True, False
有連線的例子
```
X
X__
XXX
XXX
XX_
_XX
X
_XX
X
```
沒連線的例子
```
XX_
X__
_XX
X
XX_
X_X
__X
XX
_X
```
End of explanation |
3,494 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
gappa tutorial
In this tutorial you will learn step-by-step to use gappa in order to
* calculate an SED from a particle distribution
* perform a particle evolution in the presence of energy losses
* calculate some galactic gas densities
* tinker with the galactic spiral arm structure
* dice some random galactic pulsar positions
1. Get the SED from a particle distribution
create a 2D numpy array representing an electron and a
proton SED.
The shape is your choice, but the normalisation
should be 10^50erg
in protons and 10^47erg in electrons!
Step1: Get an energy axis
Step2: Make your spectral assumption
Step3: Roughly normalise with numpy
Step4: And the result looks like this
Step5: Initialise a gappa Radiation object and set these spectra
Step6: Now set some parameters
Step7: In order to set radiation fields, you can either
* add a greybody
* set a custom spectrum
Step8: Add a crazy radiation field
Step9: Finally, calculate and retrieve the SEDs
Step10: Thumbs Up!
2. Do a particle evolution
Steps
Step11: Now define luminosity and B-field evolution.
NOTE
Step12: Create a 'Particle' object and set these evolutions
Step13: For IC losses, a lookup has to be created.
This is done with the 'Radiation' object.
Let's just use the previously defined radiation field.
Step14: The only thing missing is the shape of the injection spectrum.
Let's assume our source is injecting a broken power law
Step15: Now we can do the evolution calculation!
Step16: Now let's calculate the radiation spectrum.
Here, we set the parameters of the radiation object that
corresponds to the what's in the 'Particle' object at t=age
Step17: And plot it
Step18: 3. Dice some galactic distributions
Now let's try to dice some galactic distributions!
First lets dice some x-y coordinates in the galactic disk
Step19: Initialise an 'Astro' object
Step20: Function that gets hydrogen densities at (x,y,0) coordinates,
either from the original model by Ferriere 2001 and modulated
with spiral arms
Step21: Plot the unmodulated and modulated densities
Step22: Disable an arm, change the arm model, change the arms width
Step23: Now get some random positions in the galaxy that follows
the Case&Bhattacharya surface density model | Python Code:
%matplotlib inline
import gappa as gp
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm
Explanation: gappa tutorial
In this tutorial you will learn step-by-step to use gappa in order to
* calculate an SED from a particle distribution
* perform a particle evolution in the presence of energy losses
* calculate some galactic gas densities
* tinker with the galactic spiral arm structure
* dice some random galactic pulsar positions
1. Get the SED from a particle distribution
create a 2D numpy array representing an electron and a
proton SED.
The shape is your choice, but the normalisation
should be 10^50erg
in protons and 10^47erg in electrons!
End of explanation
# note: all input energies are in erg!
emin = 1e-3 * gp.TeV_to_erg
emax = 1e4 * gp.TeV_to_erg
e = np.logspace(np.log10(emin),np.log10(emax),100)
Explanation: Get an energy axis:
End of explanation
# my choice is a power-law for the electrons
# and protons with spectral index 'spind' and
# exp.cut-off at 'ecute'(electrons) and 'ecutp'(protons)
# plus a oscillation for the protons
spind = 2.1
ecute = 1e2 * gp.TeV_to_erg
ecutp = 1e3 * gp.TeV_to_erg
# energy in particles
we = 1e47
wp = 1e50
nel = e**(-spind) * np.exp(-e/ecute)
npr = e**(-spind) * np.exp(-e/ecutp) * (1 + np.sin(5*np.log10(e)))
Explanation: Make your spectral assumption:
End of explanation
nel *= we/np.sum((e * nel)[1:]* np.diff(e))
npr *= wp/np.sum((e * npr)[1:]* np.diff(e))
Explanation: Roughly normalise with numpy:
End of explanation
plt.loglog(e,e*e*npr,c="red")
plt.loglog(e,e*e*nel,c="blue")
plt.ylim(1.e38,1.e54)
Explanation: And the result looks like this:
End of explanation
rad = gp.Radiation()
# gappa takes 2D arrays as input
rad.SetElectrons(zip(e,nel))
rad.SetProtons(zip(e,npr))
Explanation: Initialise a gappa Radiation object and set these spectra:
End of explanation
# BField in Gauss
rad.SetBField(1e-5)
# Distance in pc
rad.SetDistance(1e3)
# Ambient density in cm^-3
rad.SetAmbientDensity(1.)
Explanation: Now set some parameters:
End of explanation
# again, energies are always in erg!
rad.AddThermalTargetPhotons(2.7,0.25*gp.eV_to_erg) #CMB
rad.AddThermalTargetPhotons(50.,0.5*gp.eV_to_erg) #some FIR field
targ = np.array(rad.GetTargetPhotons())
plt.loglog(targ[:,0],targ[:,1])
plt.ylim(1e13,1e19)
Explanation: In order to set radiation fields, you can either
* add a greybody
* set a custom spectrum
End of explanation
et = np.logspace(-20,-13,100)
nt = 1.e16*(1.+10.*np.sin(10.*np.log10(et))/np.log10(et))
rad.AddArbitraryTargetPhotons(zip(et,nt))
targ = np.array(rad.GetTargetPhotons())
plt.loglog(targ[:,0],targ[:,1])
plt.ylim(1e13,1e19)
Explanation: Add a crazy radiation field:
End of explanation
rad.CalculateDifferentialPhotonSpectrum()
to = np.array(rad.GetTotalSED())
pp = np.array(rad.GetPPSED())
ic = np.array(rad.GetICSED())
br = np.array(rad.GetBremsstrahlungSED())
sy = np.array(rad.GetSynchrotronSED())
plt.loglog(to[:,0],to[:,1],c="black")
plt.loglog(pp[:,0],pp[:,1],c="green")
plt.loglog(sy[:,0],sy[:,1],c="blue")
plt.loglog(br[:,0],br[:,1],c="red")
plt.loglog(ic[:,0],ic[:,1],c="orange")
plt.ylim(1e-14,1e-9)
Explanation: Finally, calculate and retrieve the SEDs:
End of explanation
# note: all times are in years
age = 1e3
tmin = 1e1
tmax = age * 1e6 # this has to be high!
t = np.logspace(np.log10(tmin),np.log10(tmax),200)
Explanation: Thumbs Up!
2. Do a particle evolution
Steps:
* Set source age
* set luminosity evolution
* set B-field evolution
* set ambient density
* set lookup for IC losses
Set age and make a time axis:
End of explanation
bt = 1e-3 / np.sqrt(t)
lumt = 1e38/(1. + t/500.)**2
plt.plot(t,bt)
plt.xlim(0.,1000.)
plt.plot(t,lumt)
plt.xlim(0.,1000.)
Explanation: Now define luminosity and B-field evolution.
NOTE: If you have time-dependent losses, the speed of the
calculation is determined by the strength of the losses.
The higher the losses (e.g. very high B-field), the slower.
End of explanation
par = gp.Particles()
par.SetAge(age)
par.SetBFieldLookup(zip(t,bt))
par.SetLuminosityLookup(zip(t,lumt))
par.SetAmbientDensity(2.)
Explanation: Create a 'Particle' object and set these evolutions
End of explanation
rad.CreateICLossLookup()
icl = np.array(rad.GetICLossLookup())
plt.loglog(icl[:,0],icl[:,1],c="black")
par.SetICLossLookup(icl)
Explanation: For IC losses, a lookup has to be created.
This is done with the 'Radiation' object.
Let's just use the previously defined radiation field.
End of explanation
par.SetLowSpectralIndex(1.5)
par.SetSpectralIndex(2.5)
par.SetBreakEnergy(0.1*gp.TeV_to_erg)
par.SetEmax(5e2)
Explanation: The only thing missing is the shape of the injection spectrum.
Let's assume our source is injecting a broken power law:
End of explanation
par.CalculateParticleSpectrum("electrons")
el = np.array(par.GetParticleSED())
plt.loglog(el[:,0],el[:,1],c="black")
plt.ylim(1e41,1e48)
par.SetAge(.1*age)
par.CalculateParticleSpectrum("electrons")
el2 = np.array(par.GetParticleSED())
plt.loglog(el2[:,0],el2[:,1],c="red")
par.SetAge(10.*age)
par.CalculateParticleSpectrum("electrons")
el3 = np.array(par.GetParticleSED())
plt.loglog(el3[:,0],el3[:,1],c="blue")
par.SetAge(100.*age)
par.CalculateParticleSpectrum("electrons")
el4 = np.array(par.GetParticleSED())
plt.loglog(el4[:,0],el4[:,1],c="orange")
Explanation: Now we can do the evolution calculation!
End of explanation
rad.SetBField(par.GetBField())
rad.SetAmbientDensity(par.GetAmbientDensity())
rad.SetElectrons(par.GetParticleSpectrum())
print par.GetBField()
rad.CalculateDifferentialPhotonSpectrum()
to = np.array(rad.GetTotalSED())
pp = np.array(rad.GetPPSED())
ic = np.array(rad.GetICSED())
br = np.array(rad.GetBremsstrahlungSED())
sy = np.array(rad.GetSynchrotronSED())
Explanation: Now let's calculate the radiation spectrum.
Here, we set the parameters of the radiation object that
corresponds to the what's in the 'Particle' object at t=age
End of explanation
#plt.loglog(to[:,0],to[:,1],c="black")
plt.loglog(sy[:,0],sy[:,1],c="blue")
plt.loglog(br[:,0],br[:,1],c="red")
plt.loglog(ic[:,0],ic[:,1],c="orange")
plt.ylim(1e-16,1e-9)
Explanation: And plot it:
End of explanation
bb = 20000
xx = 20*np.random.random(bb)-10
yy = 20*np.random.random(bb)-5
Explanation: 3. Dice some galactic distributions
Now let's try to dice some galactic distributions!
First lets dice some x-y coordinates in the galactic disk:
End of explanation
ao = gp.Astro()
Explanation: Initialise an 'Astro' object:
End of explanation
def get_densities(xx,yy):
nn = []
nnmod = []
for i in xrange(len(xx)):
n = ao.HIDensity(xx[i],yy[i],0.)+ao.H2Density(xx[i],yy[i],0.)
nn.append(n)
nm = ao.ModulateGasDensityWithSpirals(n,xx[i],yy[i],0.)
nnmod.append(nm)
return nn,nnmod
nn,nnmod = get_densities(xx,yy)
Explanation: Function that gets hydrogen densities at (x,y,0) coordinates,
either from the original model by Ferriere 2001 and modulated
with spiral arms:
End of explanation
plt.hist2d(xx,yy,weights=nn,normed=False,bins=(50,50),cmap=plt.cm.copper_r,alpha=1.,norm=LogNorm())
cb = plt.colorbar()
plt.hist2d(xx,yy,weights=nnmod,normed=False,bins=(50,50),cmap=plt.cm.copper_r,alpha=1.,norm=LogNorm())
cb = plt.colorbar()
Explanation: Plot the unmodulated and modulated densities:
End of explanation
ao.DisableArm(1)
dummy,nnmodnoarm = get_densities(xx,yy)
ao.EnableArm(4)
ao.SetSpiralArmModel("TaylorCordes")
dummy,nnmodtc = get_densities(xx,yy)
ao.SetArmWidth(0.2)
dummy,nnmodthin = get_densities(xx,yy)
plt.hist2d(xx,yy,weights=nnmodnoarm,normed=False,bins=(50,50),cmap=plt.cm.copper_r,alpha=1.,norm=LogNorm())
cb = plt.colorbar()
plt.hist2d(xx,yy,weights=nnmodtc,normed=False,bins=(50,50),cmap=plt.cm.copper_r,alpha=1.,norm=LogNorm())
cb = plt.colorbar()
plt.hist2d(xx,yy,weights=nnmodthin,normed=False,bins=(50,50),cmap=plt.cm.copper_r,alpha=1.,norm=LogNorm())
cb = plt.colorbar()
Explanation: Disable an arm, change the arm model, change the arms width:
End of explanation
ao.SetSpiralArmModel("Vallee")
pos = np.array(ao.DiceGalacticPositions(100))
plt.hist2d(xx,yy,weights=nnmod,normed=False,bins=(50,50),cmap=plt.cm.copper_r,alpha=1.,norm=LogNorm())
cb = plt.colorbar()
plt.scatter(pos[:,0],pos[:,1],c="white")
Explanation: Now get some random positions in the galaxy that follows
the Case&Bhattacharya surface density model:
End of explanation |
3,495 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Tutorial 1
Step1: if you want to see logging events.
From Strings to Vectors
This time, let’s start from documents represented as strings
Step2: This is a tiny corpus of nine documents, each consisting of only a single sentence.
First, let’s tokenize the documents, remove common words (using a toy stoplist) as well as words that only appear once in the corpus
Step3: Your way of processing the documents will likely vary; here, I only split on whitespace to tokenize, followed by lowercasing each word. In fact, I use this particular (simplistic and inefficient) setup to mimic the experiment done in Deerwester et al.’s original LSA article (Table 2).
The ways to process documents are so varied and application- and language-dependent that I decided to not constrain them by any interface. Instead, a document is represented by the features extracted from it, not by its “surface” string form
Step4: Here we assigned a unique integer id to all words appearing in the corpus with the gensim.corpora.dictionary.Dictionary class. This sweeps across the texts, collecting word counts and relevant statistics. In the end, we see there are twelve distinct words in the processed corpus, which means each document will be represented by twelve numbers (ie., by a 12-D vector). To see the mapping between words and their ids
Step5: To actually convert tokenized documents to vectors
Step6: The function doc2bow() simply counts the number of occurrences of each distinct word, converts the word to its integer word id and returns the result as a sparse vector. The sparse vector [(word_id, 1), (word_id, 1)] therefore reads
Step7: By now it should be clear that the vector feature with id=10 stands for the question “How many times does the word graph appear in the document?” and that the answer is “zero” for the first six documents and “one” for the remaining three. As a matter of fact, we have arrived at exactly the same corpus of vectors as in the Quick Example. If you're running this notebook by your own, the words id may differ, but you should be able to check the consistency between documents comparing their vectors.
Corpus Streaming – One Document at a Time
Note that corpus above resides fully in memory, as a plain Python list. In this simple example, it doesn’t matter much, but just to make things clear, let’s assume there are millions of documents in the corpus. Storing all of them in RAM won’t do. Instead, let’s assume the documents are stored in a file on disk, one document per line. Gensim only requires that a corpus must be able to return one document vector at a time
Step8: The assumption that each document occupies one line in a single file is not important; you can mold the __iter__ function to fit your input format, whatever it is. Walking directories, parsing XML, accessing network... Just parse your input to retrieve a clean list of tokens in each document, then convert the tokens via a dictionary to their ids and yield the resulting sparse vector inside __iter__.
Step9: Corpus is now an object. We didn’t define any way to print it, so print just outputs address of the object in memory. Not very useful. To see the constituent vectors, let’s iterate over the corpus and print each document vector (one at a time)
Step10: Although the output is the same as for the plain Python list, the corpus is now much more memory friendly, because at most one vector resides in RAM at a time. Your corpus can now be as large as you want.
Similarly, to construct the dictionary without loading all texts into memory
Step11: And that is all there is to it! At least as far as bag-of-words representation is concerned. Of course, what we do with such corpus is another question; it is not at all clear how counting the frequency of distinct words could be useful. As it turns out, it isn’t, and we will need to apply a transformation on this simple representation first, before we can use it to compute any meaningful document vs. document similarities. Transformations are covered in the next tutorial, but before that, let’s briefly turn our attention to corpus persistency.
Corpus Formats
There exist several file formats for serializing a Vector Space corpus (~sequence of vectors) to disk. Gensim implements them via the streaming corpus interface mentioned earlier
Step12: Other formats include Joachim’s SVMlight format, Blei’s LDA-C format and GibbsLDA++ format.
Step13: Conversely, to load a corpus iterator from a Matrix Market file
Step14: Corpus objects are streams, so typically you won’t be able to print them directly
Step15: Instead, to view the contents of a corpus
Step16: or
Step17: The second way is obviously more memory-friendly, but for testing and development purposes, nothing beats the simplicity of calling list(corpus).
To save the same Matrix Market document stream in Blei’s LDA-C format,
Step18: In this way, gensim can also be used as a memory-efficient I/O format conversion tool
Step19: and from/to scipy.sparse matrices | Python Code:
import logging
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
Explanation: Tutorial 1: Corpora and Vector Spaces
See this gensim tutorial on the web here.
Don’t forget to set:
End of explanation
from gensim import corpora
documents = ["Human machine interface for lab abc computer applications",
"A survey of user opinion of computer system response time",
"The EPS user interface management system",
"System and human system engineering testing of EPS",
"Relation of user perceived response time to error measurement",
"The generation of random binary unordered trees",
"The intersection graph of paths in trees",
"Graph minors IV Widths of trees and well quasi ordering",
"Graph minors A survey"]
Explanation: if you want to see logging events.
From Strings to Vectors
This time, let’s start from documents represented as strings:
End of explanation
# remove common words and tokenize
stoplist = set('for a of the and to in'.split())
texts = [[word for word in document.lower().split() if word not in stoplist]
for document in documents]
# remove words that appear only once
from collections import defaultdict
frequency = defaultdict(int)
for text in texts:
for token in text:
frequency[token] += 1
texts = [[token for token in text if frequency[token] > 1] for text in texts]
from pprint import pprint # pretty-printer
pprint(texts)
Explanation: This is a tiny corpus of nine documents, each consisting of only a single sentence.
First, let’s tokenize the documents, remove common words (using a toy stoplist) as well as words that only appear once in the corpus:
End of explanation
dictionary = corpora.Dictionary(texts)
dictionary.save('/tmp/deerwester.dict') # store the dictionary, for future reference
print(dictionary)
Explanation: Your way of processing the documents will likely vary; here, I only split on whitespace to tokenize, followed by lowercasing each word. In fact, I use this particular (simplistic and inefficient) setup to mimic the experiment done in Deerwester et al.’s original LSA article (Table 2).
The ways to process documents are so varied and application- and language-dependent that I decided to not constrain them by any interface. Instead, a document is represented by the features extracted from it, not by its “surface” string form: how you get to the features is up to you. Below I describe one common, general-purpose approach (called bag-of-words), but keep in mind that different application domains call for different features, and, as always, it’s garbage in, garbage out...
To convert documents to vectors, we’ll use a document representation called bag-of-words. In this representation, each document is represented by one vector where each vector element represents a question-answer pair, in the style of:
"How many times does the word system appear in the document? Once"
It is advantageous to represent the questions only by their (integer) ids. The mapping between the questions and ids is called a dictionary:
End of explanation
print(dictionary.token2id)
Explanation: Here we assigned a unique integer id to all words appearing in the corpus with the gensim.corpora.dictionary.Dictionary class. This sweeps across the texts, collecting word counts and relevant statistics. In the end, we see there are twelve distinct words in the processed corpus, which means each document will be represented by twelve numbers (ie., by a 12-D vector). To see the mapping between words and their ids:
End of explanation
new_doc = "Human computer interaction"
new_vec = dictionary.doc2bow(new_doc.lower().split())
print(new_vec) # the word "interaction" does not appear in the dictionary and is ignored
Explanation: To actually convert tokenized documents to vectors:
End of explanation
corpus = [dictionary.doc2bow(text) for text in texts]
corpora.MmCorpus.serialize('/tmp/deerwester.mm', corpus) # store to disk, for later use
for c in corpus:
print(c)
Explanation: The function doc2bow() simply counts the number of occurrences of each distinct word, converts the word to its integer word id and returns the result as a sparse vector. The sparse vector [(word_id, 1), (word_id, 1)] therefore reads: in the document “Human computer interaction”, the words "computer" and "human", identified by an integer id given by the built dictionary, appear once; the other ten dictionary words appear (implicitly) zero times. Check their id at the dictionary displayed in the previous cell and see that they match.
End of explanation
class MyCorpus(object):
def __iter__(self):
for line in open('datasets/mycorpus.txt'):
# assume there's one document per line, tokens separated by whitespace
yield dictionary.doc2bow(line.lower().split())
Explanation: By now it should be clear that the vector feature with id=10 stands for the question “How many times does the word graph appear in the document?” and that the answer is “zero” for the first six documents and “one” for the remaining three. As a matter of fact, we have arrived at exactly the same corpus of vectors as in the Quick Example. If you're running this notebook by your own, the words id may differ, but you should be able to check the consistency between documents comparing their vectors.
Corpus Streaming – One Document at a Time
Note that corpus above resides fully in memory, as a plain Python list. In this simple example, it doesn’t matter much, but just to make things clear, let’s assume there are millions of documents in the corpus. Storing all of them in RAM won’t do. Instead, let’s assume the documents are stored in a file on disk, one document per line. Gensim only requires that a corpus must be able to return one document vector at a time:
End of explanation
corpus_memory_friendly = MyCorpus() # doesn't load the corpus into memory!
print(corpus_memory_friendly)
Explanation: The assumption that each document occupies one line in a single file is not important; you can mold the __iter__ function to fit your input format, whatever it is. Walking directories, parsing XML, accessing network... Just parse your input to retrieve a clean list of tokens in each document, then convert the tokens via a dictionary to their ids and yield the resulting sparse vector inside __iter__.
End of explanation
for vector in corpus_memory_friendly: # load one vector into memory at a time
print(vector)
Explanation: Corpus is now an object. We didn’t define any way to print it, so print just outputs address of the object in memory. Not very useful. To see the constituent vectors, let’s iterate over the corpus and print each document vector (one at a time):
End of explanation
from six import iteritems
# collect statistics about all tokens
dictionary = corpora.Dictionary(line.lower().split() for line in open('datasets/mycorpus.txt'))
# remove stop words and words that appear only once
stop_ids = [dictionary.token2id[stopword] for stopword in stoplist
if stopword in dictionary.token2id]
once_ids = [tokenid for tokenid, docfreq in iteritems(dictionary.dfs) if docfreq == 1]
# remove stop words and words that appear only once
dictionary.filter_tokens(stop_ids + once_ids)
# remove gaps in id sequence after words that were removed
dictionary.compactify()
print(dictionary)
Explanation: Although the output is the same as for the plain Python list, the corpus is now much more memory friendly, because at most one vector resides in RAM at a time. Your corpus can now be as large as you want.
Similarly, to construct the dictionary without loading all texts into memory:
End of explanation
# create a toy corpus of 2 documents, as a plain Python list
corpus = [[(1, 0.5)], []] # make one document empty, for the heck of it
corpora.MmCorpus.serialize('/tmp/corpus.mm', corpus)
Explanation: And that is all there is to it! At least as far as bag-of-words representation is concerned. Of course, what we do with such corpus is another question; it is not at all clear how counting the frequency of distinct words could be useful. As it turns out, it isn’t, and we will need to apply a transformation on this simple representation first, before we can use it to compute any meaningful document vs. document similarities. Transformations are covered in the next tutorial, but before that, let’s briefly turn our attention to corpus persistency.
Corpus Formats
There exist several file formats for serializing a Vector Space corpus (~sequence of vectors) to disk. Gensim implements them via the streaming corpus interface mentioned earlier: documents are read from (resp. stored to) disk in a lazy fashion, one document at a time, without the whole corpus being read into main memory at once.
One of the more notable file formats is the Matrix Market format. To save a corpus in the Matrix Market format:
End of explanation
corpora.SvmLightCorpus.serialize('/tmp/corpus.svmlight', corpus)
corpora.BleiCorpus.serialize('/tmp/corpus.lda-c', corpus)
corpora.LowCorpus.serialize('/tmp/corpus.low', corpus)
Explanation: Other formats include Joachim’s SVMlight format, Blei’s LDA-C format and GibbsLDA++ format.
End of explanation
corpus = corpora.MmCorpus('/tmp/corpus.mm')
Explanation: Conversely, to load a corpus iterator from a Matrix Market file:
End of explanation
print(corpus)
Explanation: Corpus objects are streams, so typically you won’t be able to print them directly:
End of explanation
# one way of printing a corpus: load it entirely into memory
print(list(corpus)) # calling list() will convert any sequence to a plain Python list
Explanation: Instead, to view the contents of a corpus:
End of explanation
# another way of doing it: print one document at a time, making use of the streaming interface
for doc in corpus:
print(doc)
Explanation: or
End of explanation
corpora.BleiCorpus.serialize('/tmp/corpus.lda-c', corpus)
Explanation: The second way is obviously more memory-friendly, but for testing and development purposes, nothing beats the simplicity of calling list(corpus).
To save the same Matrix Market document stream in Blei’s LDA-C format,
End of explanation
import gensim
import numpy as np
numpy_matrix = np.random.randint(10, size=[5,2])
corpus = gensim.matutils.Dense2Corpus(numpy_matrix)
numpy_matrix_dense = gensim.matutils.corpus2dense(corpus, num_terms=10)
Explanation: In this way, gensim can also be used as a memory-efficient I/O format conversion tool: just load a document stream using one format and immediately save it in another format. Adding new formats is dead easy, check out the code for the SVMlight corpus for an example.
Compatibility with NumPy and SciPy
Gensim also contains efficient utility functions to help converting from/to numpy matrices:
End of explanation
import scipy.sparse
scipy_sparse_matrix = scipy.sparse.random(5,2)
corpus = gensim.matutils.Sparse2Corpus(scipy_sparse_matrix)
scipy_csc_matrix = gensim.matutils.corpus2csc(corpus)
Explanation: and from/to scipy.sparse matrices:
End of explanation |
3,496 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
GET THE DATA
Step1: EXPLORE THE DATA
Step2: SUBSET THE DATA
Step3: STANDARDIZE THE DATA
Step5: K-MEANS ANALYSIS - INITIAL CLUSTER SET
Step6: Interpret 2 cluster solution
Step7: BEGIN multiple steps to merge cluster assignment with clustering variables to examine cluster variable means by cluster
Step8: calculate clustering variable means by cluster
Step9: validate clusters in training data by examining cluster differences in CLASS using ANOVA first have to merge CLASS of poker hand with clustering variables and cluster assignment data | Python Code:
# read training and test data from the url link and save the file to your working directory
url = "http://archive.ics.uci.edu/ml/machine-learning-databases/poker/poker-hand-training-true.data"
urllib.request.urlretrieve(url, "poker_train.csv")
url2 = "http://archive.ics.uci.edu/ml/machine-learning-databases/poker/poker-hand-testing.data"
urllib.request.urlretrieve(url2, "poker_test.csv")
# read the data in and add column names
data_train = pd.read_csv("poker_train.csv", header=None,
names=['S1', 'C1', 'S2', 'C2', 'S3', 'C3','S4', 'C4', 'S5', 'C5', 'CLASS'])
data_test = pd.read_csv("poker_test.csv", header=None,
names=['S1', 'C1', 'S2', 'C2', 'S3', 'C3','S4', 'C4', 'S5', 'C5', 'CLASS'])
Explanation: GET THE DATA
End of explanation
# summary statistics including counts, mean, stdev, quartiles for the training dataset
data_train.head(n=5)
data_train.dtypes # data types of each variable
data_train.describe()
Explanation: EXPLORE THE DATA
End of explanation
# subset clustering variables
cluster=data_train[['S1', 'C1', 'S2', 'C2', 'S3', 'C3','S4', 'C4', 'S5', 'C5']]
Explanation: SUBSET THE DATA
End of explanation
# standardize clustering variables to have mean=0 and sd=1 so that card suit and
# rank are on the same scale as to have the variables equally contribute to the analysis
clustervar=cluster.copy() # create a copy
clustervar['S1']=preprocessing.scale(clustervar['S1'].astype('float64'))
clustervar['C1']=preprocessing.scale(clustervar['C1'].astype('float64'))
clustervar['S2']=preprocessing.scale(clustervar['S2'].astype('float64'))
clustervar['C2']=preprocessing.scale(clustervar['C2'].astype('float64'))
clustervar['S3']=preprocessing.scale(clustervar['S3'].astype('float64'))
clustervar['C3']=preprocessing.scale(clustervar['C3'].astype('float64'))
clustervar['S4']=preprocessing.scale(clustervar['S4'].astype('float64'))
clustervar['C4']=preprocessing.scale(clustervar['C4'].astype('float64'))
clustervar['S5']=preprocessing.scale(clustervar['S5'].astype('float64'))
clustervar['C5']=preprocessing.scale(clustervar['C5'].astype('float64'))
# The data has been already split data into train and test sets
clus_train = clustervar
Explanation: STANDARDIZE THE DATA
End of explanation
# k-means cluster analysis for 1-10 clusters due to the 10 possible class outcomes for poker hands
from scipy.spatial.distance import cdist
clusters=range(1,11)
meandist=[]
# loop through each cluster and fit the model to the train set
# generate the predicted cluster assingment and append the mean distance my taking the sum divided by the shape
for k in clusters:
model=KMeans(n_clusters=k)
model.fit(clus_train)
clusassign=model.predict(clus_train)
meandist.append(sum(np.min(cdist(clus_train, model.cluster_centers_, 'euclidean'), axis=1))
/ clus_train.shape[0])
Plot average distance from observations from the cluster centroid
to use the Elbow Method to identify number of clusters to choose
plt.plot(clusters, meandist)
plt.xlabel('Number of clusters')
plt.ylabel('Average distance')
plt.title('Selecting k with the Elbow Method') # pick the fewest number of clusters that reduces the average distance
Explanation: K-MEANS ANALYSIS - INITIAL CLUSTER SET
End of explanation
model3=KMeans(n_clusters=2)
model3.fit(clus_train) # has cluster assingments based on using 2 clusters
clusassign=model3.predict(clus_train)
# plot clusters
''' Canonical Discriminant Analysis for variable reduction:
1. creates a smaller number of variables
2. linear combination of clustering variables
3. Canonical variables are ordered by proportion of variance accounted for
4. most of the variance will be accounted for in the first few canonical variables
'''
from sklearn.decomposition import PCA # CA from PCA function
pca_2 = PCA(2) # return 2 first canonical variables
plot_columns = pca_2.fit_transform(clus_train) # fit CA to the train dataset
plt.scatter(x=plot_columns[:,0], y=plot_columns[:,1], c=model3.labels_,) # plot 1st canonical variable on x axis, 2nd on y-axis
plt.xlabel('Canonical variable 1')
plt.ylabel('Canonical variable 2')
plt.title('Scatterplot of Canonical Variables for 2 Clusters')
plt.show() # close or overlapping clusters idicate correlated variables with low in-class variance but not good separation. 2 cluster might be better.
Explanation: Interpret 2 cluster solution
End of explanation
# create a unique identifier variable from the index for the
# cluster training data to merge with the cluster assignment variable
clus_train.reset_index(level=0, inplace=True)
# create a list that has the new index variable
cluslist=list(clus_train['index'])
# create a list of cluster assignments
labels=list(model3.labels_)
# combine index variable list with cluster assignment list into a dictionary
newlist=dict(zip(cluslist, labels))
newlist
# convert newlist dictionary to a dataframe
newclus=DataFrame.from_dict(newlist, orient='index')
newclus
# rename the cluster assignment column
newclus.columns = ['cluster']
# now do the same for the cluster assignment variable create a unique identifier variable from the index for the
# cluster assignment dataframe to merge with cluster training data
newclus.reset_index(level=0, inplace=True)
# merge the cluster assignment dataframe with the cluster training variable dataframe
# by the index variable
merged_train=pd.merge(clus_train, newclus, on='index')
merged_train.head(n=100)
# cluster frequencies
merged_train.cluster.value_counts()
Explanation: BEGIN multiple steps to merge cluster assignment with clustering variables to examine cluster variable means by cluster
End of explanation
clustergrp = merged_train.groupby('cluster').mean()
print ("Clustering variable means by cluster")
print(clustergrp)
Explanation: calculate clustering variable means by cluster
End of explanation
# split into test / train for class
pokerhand_train=data_train['CLASS']
pokerhand_test=data_test['CLASS']
# put into a pandas dataFrame
pokerhand_train=pd.DataFrame(pokerhand_train)
pokerhand_test=pd.DataFrame(pokerhand_test)
pokerhand_train.reset_index(level=0, inplace=True) # reset index
merged_train_all=pd.merge(pokerhand_train, merged_train, on='index') # merge the pokerhand train with merged clusters
sub1 = merged_train_all[['CLASS', 'cluster']].dropna()
import statsmodels.formula.api as smf
import statsmodels.stats.multicomp as multi
# respone formula
pokermod = smf.ols(formula='CLASS ~ cluster', data=sub1).fit()
print (pokermod.summary())
print ('means for Poker hands by cluster')
m1= sub1.groupby('cluster').mean()
print (m1)
print ('standard deviations for Poker hands by cluster')
m2= sub1.groupby('cluster').std()
print (m2)
mc1 = multi.MultiComparison(sub1['CLASS'], sub1['cluster'])
res1 = mc1.tukeyhsd()
print(res1.summary())
Explanation: validate clusters in training data by examining cluster differences in CLASS using ANOVA first have to merge CLASS of poker hand with clustering variables and cluster assignment data
End of explanation |
3,497 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Homework #4
These problem sets focus on list comprehensions, string operations and regular expressions.
Problem set #1
Step1: In the following cell, complete the code with an expression that evaluates to a list of integers derived from the raw numbers in numbers_str, assigning the value of this expression to a variable numbers. If you do everything correctly, executing the cell should produce the output 985 (not '985').
Step2: Great! We'll be using the numbers list you created above in the next few problems.
In the cell below, fill in the square brackets so that the expression evaluates to a list of the ten largest values in numbers. Expected output
Step3: In the cell below, write an expression that evaluates to a list of the integers from numbers that are evenly divisible by three, sorted in numerical order. Expected output
Step4: Okay. You're doing great. Now, in the cell below, write an expression that evaluates to a list of the square roots of all the integers in numbers that are less than 100. In order to do this, you'll need to use the sqrt function from the math module, which I've already imported for you. Expected output
Step5: Problem set #2
Step6: Now, in the cell below, write a list comprehension that evaluates to a list of names of the planets that have a diameter greater than four earth radii. Expected output
Step7: In the cell below, write a single expression that evaluates to the sum of the mass of all planets in the solar system. Expected output
Step8: Good work. Last one with the planets. Write an expression that evaluates to the names of the planets that have the word giant anywhere in the value for their type key. Expected output
Step9: EXTREME BONUS ROUND
Step10: Problem set #3
Step11: In the cell above, I defined a variable poem_lines which has a list of lines in the poem, and imported the re library.
In the cell below, write a list comprehension (using re.search()) that evaluates to a list of lines that contain two words next to each other (separated by a space) that have exactly four characters. (Hint
Step12: Good! Now, in the following cell, write a list comprehension that evaluates to a list of lines in the poem that end with a five-letter word, regardless of whether or not there is punctuation following the word at the end of the line. (Hint
Step13: Okay, now a slightly trickier one. In the cell below, I've created a string all_lines which evaluates to the entire text of the poem in one string. Execute this cell.
Step14: Now, write an expression that evaluates to all of the words in the poem that follow the word 'I'. (The strings in the resulting list should not include the I.) Hint
Step15: Finally, something super tricky. Here's a list of strings that contains a restaurant menu. Your job is to wrangle this plain text, slightly-structured data into a list of dictionaries.
Step16: You'll need to pull out the name of the dish and the price of the dish. The v after the hyphen indicates that the dish is vegetarian---you'll need to include that information in your dictionary as well. I've included the basic framework; you just need to fill in the contents of the for loop.
Expected output | Python Code:
numbers_str = '496,258,332,550,506,699,7,985,171,581,436,804,736,528,65,855,68,279,721,120'
Explanation: Homework #4
These problem sets focus on list comprehensions, string operations and regular expressions.
Problem set #1: List slices and list comprehensions
Let's start with some data. The following cell contains a string with comma-separated integers, assigned to a variable called numbers_str:
End of explanation
numbers = [int(number) for number in numbers_str.split(',')]
max(numbers)
Explanation: In the following cell, complete the code with an expression that evaluates to a list of integers derived from the raw numbers in numbers_str, assigning the value of this expression to a variable numbers. If you do everything correctly, executing the cell should produce the output 985 (not '985').
End of explanation
sorted(numbers)[-10:]
Explanation: Great! We'll be using the numbers list you created above in the next few problems.
In the cell below, fill in the square brackets so that the expression evaluates to a list of the ten largest values in numbers. Expected output:
[506, 528, 550, 581, 699, 721, 736, 804, 855, 985]
(Hint: use a slice.)
End of explanation
[number for number in sorted(numbers) if number % 3 == 0]
Explanation: In the cell below, write an expression that evaluates to a list of the integers from numbers that are evenly divisible by three, sorted in numerical order. Expected output:
[120, 171, 258, 279, 528, 699, 804, 855]
End of explanation
from math import sqrt
[sqrt(number) for number in sorted(numbers) if number < 100]
Explanation: Okay. You're doing great. Now, in the cell below, write an expression that evaluates to a list of the square roots of all the integers in numbers that are less than 100. In order to do this, you'll need to use the sqrt function from the math module, which I've already imported for you. Expected output:
[2.6457513110645907, 8.06225774829855, 8.246211251235321]
(These outputs might vary slightly depending on your platform.)
End of explanation
planets = [
{'diameter': 0.382,
'mass': 0.06,
'moons': 0,
'name': 'Mercury',
'orbital_period': 0.24,
'rings': 'no',
'type': 'terrestrial'},
{'diameter': 0.949,
'mass': 0.82,
'moons': 0,
'name': 'Venus',
'orbital_period': 0.62,
'rings': 'no',
'type': 'terrestrial'},
{'diameter': 1.00,
'mass': 1.00,
'moons': 1,
'name': 'Earth',
'orbital_period': 1.00,
'rings': 'no',
'type': 'terrestrial'},
{'diameter': 0.532,
'mass': 0.11,
'moons': 2,
'name': 'Mars',
'orbital_period': 1.88,
'rings': 'no',
'type': 'terrestrial'},
{'diameter': 11.209,
'mass': 317.8,
'moons': 67,
'name': 'Jupiter',
'orbital_period': 11.86,
'rings': 'yes',
'type': 'gas giant'},
{'diameter': 9.449,
'mass': 95.2,
'moons': 62,
'name': 'Saturn',
'orbital_period': 29.46,
'rings': 'yes',
'type': 'gas giant'},
{'diameter': 4.007,
'mass': 14.6,
'moons': 27,
'name': 'Uranus',
'orbital_period': 84.01,
'rings': 'yes',
'type': 'ice giant'},
{'diameter': 3.883,
'mass': 17.2,
'moons': 14,
'name': 'Neptune',
'orbital_period': 164.8,
'rings': 'yes',
'type': 'ice giant'}]
Explanation: Problem set #2: Still more list comprehensions
Still looking good. Let's do a few more with some different data. In the cell below, I've defined a data structure and assigned it to a variable planets. It's a list of dictionaries, with each dictionary describing the characteristics of a planet in the solar system. Make sure to run the cell before you proceed.
End of explanation
# I think that the question has a typo. This is for planets that have a diameter greater than four Earth DIAMETERS
[planet['name'] for planet in planets if planet['diameter'] > 4 * planets[2]['diameter']]
Explanation: Now, in the cell below, write a list comprehension that evaluates to a list of names of the planets that have a diameter greater than four earth radii. Expected output:
['Jupiter', 'Saturn', 'Uranus']
End of explanation
sum([planet['mass'] for planet in planets])
Explanation: In the cell below, write a single expression that evaluates to the sum of the mass of all planets in the solar system. Expected output: 446.79
End of explanation
[planet['name'] for planet in planets if planet['type'].find('giant') > -1]
Explanation: Good work. Last one with the planets. Write an expression that evaluates to the names of the planets that have the word giant anywhere in the value for their type key. Expected output:
['Jupiter', 'Saturn', 'Uranus', 'Neptune']
End of explanation
newlist = sorted(planets, key=lambda k: k['moons'])
[planetfor planet in newlist
# sorted_moons = sorted([planet['moons'] for planet in planets])
# sorted([planet['name'] for planet in planets], key = [planet['moons'] for planet in planets])
# sorted(planets, key=[planet['moons'] for planet in planets].sort())
Explanation: EXTREME BONUS ROUND: Write an expression below that evaluates to a list of the names of the planets in ascending order by their number of moons. (The easiest way to do this involves using the key parameter of the sorted function, which we haven't yet discussed in class! That's why this is an EXTREME BONUS question.) Expected output:
for ['Mercury', 'Venus', 'Earth', 'Mars', 'Neptune', 'Uranus', 'Saturn', 'Jupiter']
End of explanation
import re
poem_lines = ['Two roads diverged in a yellow wood,',
'And sorry I could not travel both',
'And be one traveler, long I stood',
'And looked down one as far as I could',
'To where it bent in the undergrowth;',
'',
'Then took the other, as just as fair,',
'And having perhaps the better claim,',
'Because it was grassy and wanted wear;',
'Though as for that the passing there',
'Had worn them really about the same,',
'',
'And both that morning equally lay',
'In leaves no step had trodden black.',
'Oh, I kept the first for another day!',
'Yet knowing how way leads on to way,',
'I doubted if I should ever come back.',
'',
'I shall be telling this with a sigh',
'Somewhere ages and ages hence:',
'Two roads diverged in a wood, and I---',
'I took the one less travelled by,',
'And that has made all the difference.']
Explanation: Problem set #3: Regular expressions
In the following section, we're going to do a bit of digital humanities. (I guess this could also be journalism if you were... writing an investigative piece about... early 20th century American poetry?) We'll be working with the following text, Robert Frost's The Road Not Taken. Make sure to run the following cell before you proceed.
End of explanation
[line for line in poem_lines if re.search(r'\b\w{4} \b\w{4}\b', line)]
Explanation: In the cell above, I defined a variable poem_lines which has a list of lines in the poem, and imported the re library.
In the cell below, write a list comprehension (using re.search()) that evaluates to a list of lines that contain two words next to each other (separated by a space) that have exactly four characters. (Hint: use the \b anchor. Don't overthink the "two words in a row" requirement.)
Expected result:
['Then took the other, as just as fair,',
'Had worn them really about the same,',
'And both that morning equally lay',
'I doubted if I should ever come back.',
'I shall be telling this with a sigh']
End of explanation
[line for line in poem_lines if re.search(r'\b\w{5}\W?$', line)]
Explanation: Good! Now, in the following cell, write a list comprehension that evaluates to a list of lines in the poem that end with a five-letter word, regardless of whether or not there is punctuation following the word at the end of the line. (Hint: Try using the ? quantifier. Is there an existing character class, or a way to write a character class, that matches non-alphanumeric characters?) Expected output:
['And be one traveler, long I stood',
'And looked down one as far as I could',
'And having perhaps the better claim,',
'Though as for that the passing there',
'In leaves no step had trodden black.',
'Somewhere ages and ages hence:']
End of explanation
all_lines = " ".join(poem_lines)
Explanation: Okay, now a slightly trickier one. In the cell below, I've created a string all_lines which evaluates to the entire text of the poem in one string. Execute this cell.
End of explanation
re.findall(r'\bI \b(\w+)\b', all_lines)
Explanation: Now, write an expression that evaluates to all of the words in the poem that follow the word 'I'. (The strings in the resulting list should not include the I.) Hint: Use re.findall() and grouping! Expected output:
['could', 'stood', 'could', 'kept', 'doubted', 'should', 'shall', 'took']
End of explanation
entrees = [
"Yam, Rosemary and Chicken Bowl with Hot Sauce $10.95",
"Lavender and Pepperoni Sandwich $8.49",
"Water Chestnuts and Peas Power Lunch (with mayonnaise) $12.95 - v",
"Artichoke, Mustard Green and Arugula with Sesame Oil over noodles $9.95 - v",
"Flank Steak with Lentils And Tabasco Pepper With Sweet Chilli Sauce $19.95",
"Rutabaga And Cucumber Wrap $8.49 - v"
]
Explanation: Finally, something super tricky. Here's a list of strings that contains a restaurant menu. Your job is to wrangle this plain text, slightly-structured data into a list of dictionaries.
End of explanation
# Way 1
menu = []
for item in entrees:
food_entry = {}
for x in re.findall(r'(^.+) \$', item):
food_entry['name'] = str(x)
for x in re.findall(r'\$(\d+.\d{2})', item):
food_entry['price'] = float(x)
if re.search(r'- v$', item):
food_entry['vegetarian'] = True
else:
food_entry['vegetarian'] = False
menu.append(food_entry)
menu
# Way 2
menu = []
for item in entrees:
food_entry = {}
match = re.search(r'(^.+) \$(\d+.\d{2}) ?(-? ?v?$)', item)
food_entry['name'] = match.group(1)
food_entry['price'] = float(match.group(2))
if match.group(3):
food_entry['vegetarian'] = True
else:
food_entry['vegetarian'] = False
menu.append(food_entry)
menu
Explanation: You'll need to pull out the name of the dish and the price of the dish. The v after the hyphen indicates that the dish is vegetarian---you'll need to include that information in your dictionary as well. I've included the basic framework; you just need to fill in the contents of the for loop.
Expected output:
[{'name': 'Yam, Rosemary and Chicken Bowl with Hot Sauce ',
'price': 10.95,
'vegetarian': False},
{'name': 'Lavender and Pepperoni Sandwich ',
'price': 8.49,
'vegetarian': False},
{'name': 'Water Chestnuts and Peas Power Lunch (with mayonnaise) ',
'price': 12.95,
'vegetarian': True},
{'name': 'Artichoke, Mustard Green and Arugula with Sesame Oil over noodles ',
'price': 9.95,
'vegetarian': True},
{'name': 'Flank Steak with Lentils And Tabasco Pepper With Sweet Chilli Sauce ',
'price': 19.95,
'vegetarian': False},
{'name': 'Rutabaga And Cucumber Wrap ', 'price': 8.49, 'vegetarian': True}]
End of explanation |
3,498 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Character Sequence to Sequence
In this notebook, we'll build a model that takes in a sequence of letters, and outputs a sorted version of that sequence. We'll do that using what we've learned so far about Sequence to Sequence models. This notebook was updated to work with TensorFlow 1.1 and builds on the work of Dave Currie. Check out Dave's post Text Summarization with Amazon Reviews.
<img src="images/sequence-to-sequence.jpg"/>
Dataset
The dataset lives in the /data/ folder. At the moment, it is made up of the following files
Step1: Let's start by examining the current state of the dataset. source_sentences contains the entire input sequence file as text delimited by newline symbols.
Step2: source_sentences contains the entire output sequence file as text delimited by newline symbols. Each line corresponds to the line from source_sentences. source_sentences contains a sorted characters of the line.
Step3: Preprocess
To do anything useful with it, we'll need to turn the each string into a list of characters
Step4: This is the final shape we need them to be in. We can now proceed to building the model.
Model
Check the Version of TensorFlow
This will check to make sure you have the correct version of TensorFlow
Step5: Hyperparameters
Step6: Input
Step7: Sequence to Sequence Model
We can now start defining the functions that will build the seq2seq model. We are building it from the bottom up with the following components
Step8: 2.2 Decoder
The decoder is probably the most involved part of this model. The following steps are needed to create it
Step9: Set up the decoder components
- Embedding
- Decoder cell
- Dense output layer
- Training decoder
- Inference decoder
1- Embedding
Now that we have prepared the inputs to the training decoder, we need to embed them so they can be ready to be passed to the decoder.
We'll create an embedding matrix like the following then have tf.nn.embedding_lookup convert our input to its embedded equivalent
Step10: 2.3 Seq2seq model
Let's now go a step above, and hook up the encoder and decoder using the methods we just declared
Step11: Model outputs training_decoder_output and inference_decoder_output both contain a 'rnn_output' logits tensor that looks like this
Step14: Get Batches
There's little processing involved when we retreive the batches. This is a simple example assuming batch_size = 2
Source sequences (it's actually in int form, we're showing the characters for clarity)
Step15: Train
We're now ready to train our model. If you run into OOM (out of memory) issues during training, try to decrease the batch_size.
Step16: Prediction | Python Code:
import numpy as np
import time
import helper
source_path = 'data/letters_source.txt'
target_path = 'data/letters_target.txt'
source_sentences = helper.load_data(source_path)
target_sentences = helper.load_data(target_path)
Explanation: Character Sequence to Sequence
In this notebook, we'll build a model that takes in a sequence of letters, and outputs a sorted version of that sequence. We'll do that using what we've learned so far about Sequence to Sequence models. This notebook was updated to work with TensorFlow 1.1 and builds on the work of Dave Currie. Check out Dave's post Text Summarization with Amazon Reviews.
<img src="images/sequence-to-sequence.jpg"/>
Dataset
The dataset lives in the /data/ folder. At the moment, it is made up of the following files:
* letters_source.txt: The list of input letter sequences. Each sequence is its own line.
* letters_target.txt: The list of target sequences we'll use in the training process. Each sequence here is a response to the input sequence in letters_source.txt with the same line number.
End of explanation
source_sentences[:50].split('\n')
Explanation: Let's start by examining the current state of the dataset. source_sentences contains the entire input sequence file as text delimited by newline symbols.
End of explanation
target_sentences[:50].split('\n')
Explanation: source_sentences contains the entire output sequence file as text delimited by newline symbols. Each line corresponds to the line from source_sentences. source_sentences contains a sorted characters of the line.
End of explanation
def extract_character_vocab(data):
special_words = ['<PAD>', '<UNK>', '<GO>', '<EOS>']
set_words = set([character for line in data.split('\n') for character in line])
int_to_vocab = {word_i: word for word_i, word in enumerate(special_words + list(set_words))}
vocab_to_int = {word: word_i for word_i, word in int_to_vocab.items()}
return int_to_vocab, vocab_to_int
# Build int2letter and letter2int dicts
source_int_to_letter, source_letter_to_int = extract_character_vocab(source_sentences)
target_int_to_letter, target_letter_to_int = extract_character_vocab(target_sentences)
# Convert characters to ids
source_letter_ids = [[source_letter_to_int.get(letter, source_letter_to_int['<UNK>']) for letter in line] for line in source_sentences.split('\n')]
target_letter_ids = [[target_letter_to_int.get(letter, target_letter_to_int['<UNK>']) for letter in line] + [target_letter_to_int['<EOS>']] for line in target_sentences.split('\n')]
print("Example source sequence")
print(source_letter_ids[:3])
print("\n")
print("Example target sequence")
print(target_letter_ids[:3])
Explanation: Preprocess
To do anything useful with it, we'll need to turn the each string into a list of characters:
<img src="images/source_and_target_arrays.png"/>
Then convert the characters to their int values as declared in our vocabulary:
End of explanation
from distutils.version import LooseVersion
import tensorflow as tf
from tensorflow.python.layers.core import Dense
# Check TensorFlow Version
assert LooseVersion(tf.__version__) >= LooseVersion('1.1'), 'Please use TensorFlow version 1.1 or newer'
print('TensorFlow Version: {}'.format(tf.__version__))
Explanation: This is the final shape we need them to be in. We can now proceed to building the model.
Model
Check the Version of TensorFlow
This will check to make sure you have the correct version of TensorFlow
End of explanation
# Number of Epochs
epochs = 60
# Batch Size
batch_size = 128
# RNN Size
rnn_size = 50
# Number of Layers
num_layers = 2
# Embedding Size
encoding_embedding_size = 15
decoding_embedding_size = 15
# Learning Rate
learning_rate = 0.001
Explanation: Hyperparameters
End of explanation
def get_model_inputs():
input_data = tf.placeholder(tf.int32, [None, None], name='input')
targets = tf.placeholder(tf.int32, [None, None], name='targets')
lr = tf.placeholder(tf.float32, name='learning_rate')
target_sequence_length = tf.placeholder(tf.int32, (None,), name='target_sequence_length')
max_target_sequence_length = tf.reduce_max(target_sequence_length, name='max_target_len')
source_sequence_length = tf.placeholder(tf.int32, (None,), name='source_sequence_length')
return input_data, targets, lr, target_sequence_length, max_target_sequence_length, source_sequence_length
Explanation: Input
End of explanation
def encoding_layer(input_data, rnn_size, num_layers,
source_sequence_length, source_vocab_size,
encoding_embedding_size):
# Encoder embedding
enc_embed_input = tf.contrib.layers.embed_sequence(input_data, source_vocab_size, encoding_embedding_size)
# RNN cell
def make_cell(rnn_size):
enc_cell = tf.contrib.rnn.LSTMCell(rnn_size,
initializer=tf.random_uniform_initializer(-0.1, 0.1, seed=2))
return enc_cell
enc_cell = tf.contrib.rnn.MultiRNNCell([make_cell(rnn_size) for _ in range(num_layers)])
enc_output, enc_state = tf.nn.dynamic_rnn(enc_cell, enc_embed_input, sequence_length=source_sequence_length, dtype=tf.float32)
return enc_output, enc_state
Explanation: Sequence to Sequence Model
We can now start defining the functions that will build the seq2seq model. We are building it from the bottom up with the following components:
2.1 Encoder
- Embedding
- Encoder cell
2.2 Decoder
1- Process decoder inputs
2- Set up the decoder
- Embedding
- Decoder cell
- Dense output layer
- Training decoder
- Inference decoder
2.3 Seq2seq model connecting the encoder and decoder
2.4 Build the training graph hooking up the model with the
optimizer
2.1 Encoder
The first bit of the model we'll build is the encoder. Here, we'll embed the input data, construct our encoder, then pass the embedded data to the encoder.
Embed the input data using tf.contrib.layers.embed_sequence
<img src="images/embed_sequence.png" />
Pass the embedded input into a stack of RNNs. Save the RNN state and ignore the output.
<img src="images/encoder.png" />
End of explanation
# Process the input we'll feed to the decoder
def process_decoder_input(target_data, vocab_to_int, batch_size):
'''Remove the last word id from each batch and concat the <GO> to the begining of each batch'''
ending = tf.strided_slice(target_data, [0, 0], [batch_size, -1], [1, 1])
dec_input = tf.concat([tf.fill([batch_size, 1], vocab_to_int['<GO>']), ending], 1)
return dec_input
Explanation: 2.2 Decoder
The decoder is probably the most involved part of this model. The following steps are needed to create it:
1- Process decoder inputs
2- Set up the decoder components
- Embedding
- Decoder cell
- Dense output layer
- Training decoder
- Inference decoder
Process Decoder Input
In the training process, the target sequences will be used in two different places:
Using them to calculate the loss
Feeding them to the decoder during training to make the model more robust.
Now we need to address the second point. Let's assume our targets look like this in their letter/word form (we're doing this for readibility. At this point in the code, these sequences would be in int form):
<img src="images/targets_1.png"/>
We need to do a simple transformation on the tensor before feeding it to the decoder:
1- We will feed an item of the sequence to the decoder at each time step. Think about the last timestep -- where the decoder outputs the final word in its output. The input to that step is the item before last from the target sequence. The decoder has no use for the last item in the target sequence in this scenario. So we'll need to remove the last item.
We do that using tensorflow's tf.strided_slice() method. We hand it the tensor, and the index of where to start and where to end the cutting.
<img src="images/strided_slice_1.png"/>
2- The first item in each sequence we feed to the decoder has to be GO symbol. So We'll add that to the beginning.
<img src="images/targets_add_go.png"/>
Now the tensor is ready to be fed to the decoder. It looks like this (if we convert from ints to letters/symbols):
<img src="images/targets_after_processing_1.png"/>
End of explanation
def decoding_layer(target_letter_to_int, decoding_embedding_size, num_layers, rnn_size,
target_sequence_length, max_target_sequence_length, enc_state, dec_input):
# 1. Decoder Embedding
target_vocab_size = len(target_letter_to_int)
dec_embeddings = tf.Variable(tf.random_uniform([target_vocab_size, decoding_embedding_size]))
dec_embed_input = tf.nn.embedding_lookup(dec_embeddings, dec_input)
# 2. Construct the decoder cell
def make_cell(rnn_size):
dec_cell = tf.contrib.rnn.LSTMCell(rnn_size,
initializer=tf.random_uniform_initializer(-0.1, 0.1, seed=2))
return dec_cell
dec_cell = tf.contrib.rnn.MultiRNNCell([make_cell(rnn_size) for _ in range(num_layers)])
# 3. Dense layer to translate the decoder's output at each time
# step into a choice from the target vocabulary
output_layer = Dense(target_vocab_size,
kernel_initializer = tf.truncated_normal_initializer(mean = 0.0, stddev=0.1))
# 4. Set up a training decoder and an inference decoder
# Training Decoder
with tf.variable_scope("decode"):
# Helper for the training process. Used by BasicDecoder to read inputs.
training_helper = tf.contrib.seq2seq.TrainingHelper(inputs=dec_embed_input,
sequence_length=target_sequence_length,
time_major=False)
# Basic decoder
training_decoder = tf.contrib.seq2seq.BasicDecoder(dec_cell,
training_helper,
enc_state,
output_layer)
# Perform dynamic decoding using the decoder
training_decoder_output, _ = tf.contrib.seq2seq.dynamic_decode(training_decoder,
impute_finished=True,
maximum_iterations=max_target_sequence_length)
# 5. Inference Decoder
# Reuses the same parameters trained by the training process
with tf.variable_scope("decode", reuse=True):
start_tokens = tf.tile(tf.constant([target_letter_to_int['<GO>']], dtype=tf.int32), [batch_size], name='start_tokens')
# Helper for the inference process.
inference_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(dec_embeddings,
start_tokens,
target_letter_to_int['<EOS>'])
# Basic decoder
inference_decoder = tf.contrib.seq2seq.BasicDecoder(dec_cell,
inference_helper,
enc_state,
output_layer)
# Perform dynamic decoding using the decoder
inference_decoder_output, _ = tf.contrib.seq2seq.dynamic_decode(inference_decoder,
impute_finished=True,
maximum_iterations=max_target_sequence_length)
return training_decoder_output, inference_decoder_output
Explanation: Set up the decoder components
- Embedding
- Decoder cell
- Dense output layer
- Training decoder
- Inference decoder
1- Embedding
Now that we have prepared the inputs to the training decoder, we need to embed them so they can be ready to be passed to the decoder.
We'll create an embedding matrix like the following then have tf.nn.embedding_lookup convert our input to its embedded equivalent:
<img src="images/embeddings.png" />
2- Decoder Cell
Then we declare our decoder cell. Just like the encoder, we'll use an tf.contrib.rnn.LSTMCell here as well.
We need to declare a decoder for the training process, and a decoder for the inference/prediction process. These two decoders will share their parameters (so that all the weights and biases that are set during the training phase can be used when we deploy the model).
First, we'll need to define the type of cell we'll be using for our decoder RNNs. We opted for LSTM.
3- Dense output layer
Before we move to declaring our decoders, we'll need to create the output layer, which will be a tensorflow.python.layers.core.Dense layer that translates the outputs of the decoder to logits that tell us which element of the decoder vocabulary the decoder is choosing to output at each time step.
4- Training decoder
Essentially, we'll be creating two decoders which share their parameters. One for training and one for inference. The two are similar in that both created using tf.contrib.seq2seq.BasicDecoder and tf.contrib.seq2seq.dynamic_decode. They differ, however, in that we feed the the target sequences as inputs to the training decoder at each time step to make it more robust.
We can think of the training decoder as looking like this (except that it works with sequences in batches):
<img src="images/sequence-to-sequence-training-decoder.png"/>
The training decoder does not feed the output of each time step to the next. Rather, the inputs to the decoder time steps are the target sequence from the training dataset (the orange letters).
5- Inference decoder
The inference decoder is the one we'll use when we deploy our model to the wild.
<img src="images/sequence-to-sequence-inference-decoder.png"/>
We'll hand our encoder hidden state to both the training and inference decoders and have it process its output. TensorFlow handles most of the logic for us. We just have to use the appropriate methods from tf.contrib.seq2seq and supply them with the appropriate inputs.
End of explanation
def seq2seq_model(input_data, targets, lr, target_sequence_length,
max_target_sequence_length, source_sequence_length,
source_vocab_size, target_vocab_size,
enc_embedding_size, dec_embedding_size,
rnn_size, num_layers):
# Pass the input data through the encoder. We'll ignore the encoder output, but use the state
_, enc_state = encoding_layer(input_data,
rnn_size,
num_layers,
source_sequence_length,
source_vocab_size,
encoding_embedding_size)
# Prepare the target sequences we'll feed to the decoder in training mode
dec_input = process_decoder_input(targets, target_letter_to_int, batch_size)
# Pass encoder state and decoder inputs to the decoders
training_decoder_output, inference_decoder_output = decoding_layer(target_letter_to_int,
decoding_embedding_size,
num_layers,
rnn_size,
target_sequence_length,
max_target_sequence_length,
enc_state,
dec_input)
return training_decoder_output, inference_decoder_output
Explanation: 2.3 Seq2seq model
Let's now go a step above, and hook up the encoder and decoder using the methods we just declared
End of explanation
# Build the graph
train_graph = tf.Graph()
# Set the graph to default to ensure that it is ready for training
with train_graph.as_default():
# Load the model inputs
input_data, targets, lr, target_sequence_length, max_target_sequence_length, source_sequence_length = get_model_inputs()
# Create the training and inference logits
training_decoder_output, inference_decoder_output = seq2seq_model(input_data,
targets,
lr,
target_sequence_length,
max_target_sequence_length,
source_sequence_length,
len(source_letter_to_int),
len(target_letter_to_int),
encoding_embedding_size,
decoding_embedding_size,
rnn_size,
num_layers)
# Create tensors for the training logits and inference logits
training_logits = tf.identity(training_decoder_output.rnn_output, 'logits')
inference_logits = tf.identity(inference_decoder_output.sample_id, name='predictions')
# Create the weights for sequence_loss
masks = tf.sequence_mask(target_sequence_length, max_target_sequence_length, dtype=tf.float32, name='masks')
with tf.name_scope("optimization"):
# Loss function
cost = tf.contrib.seq2seq.sequence_loss(
training_logits,
targets,
masks)
# Optimizer
optimizer = tf.train.AdamOptimizer(lr)
# Gradient Clipping
gradients = optimizer.compute_gradients(cost)
capped_gradients = [(tf.clip_by_value(grad, -5., 5.), var) for grad, var in gradients if grad is not None]
train_op = optimizer.apply_gradients(capped_gradients)
Explanation: Model outputs training_decoder_output and inference_decoder_output both contain a 'rnn_output' logits tensor that looks like this:
<img src="images/logits.png"/>
The logits we get from the training tensor we'll pass to tf.contrib.seq2seq.sequence_loss() to calculate the loss and ultimately the gradient.
End of explanation
def pad_sentence_batch(sentence_batch, pad_int):
Pad sentences with <PAD> so that each sentence of a batch has the same length
max_sentence = max([len(sentence) for sentence in sentence_batch])
return [sentence + [pad_int] * (max_sentence - len(sentence)) for sentence in sentence_batch]
def get_batches(targets, sources, batch_size, source_pad_int, target_pad_int):
Batch targets, sources, and the lengths of their sentences together
for batch_i in range(0, len(sources)//batch_size):
start_i = batch_i * batch_size
sources_batch = sources[start_i:start_i + batch_size]
targets_batch = targets[start_i:start_i + batch_size]
pad_sources_batch = np.array(pad_sentence_batch(sources_batch, source_pad_int))
pad_targets_batch = np.array(pad_sentence_batch(targets_batch, target_pad_int))
# Need the lengths for the _lengths parameters
pad_targets_lengths = []
for target in pad_targets_batch:
pad_targets_lengths.append(len(target))
pad_source_lengths = []
for source in pad_sources_batch:
pad_source_lengths.append(len(source))
yield pad_targets_batch, pad_sources_batch, pad_targets_lengths, pad_source_lengths
Explanation: Get Batches
There's little processing involved when we retreive the batches. This is a simple example assuming batch_size = 2
Source sequences (it's actually in int form, we're showing the characters for clarity):
<img src="images/source_batch.png" />
Target sequences (also in int, but showing letters for clarity):
<img src="images/target_batch.png" />
End of explanation
# Split data to training and validation sets
train_source = source_letter_ids[batch_size:]
train_target = target_letter_ids[batch_size:]
valid_source = source_letter_ids[:batch_size]
valid_target = target_letter_ids[:batch_size]
(valid_targets_batch, valid_sources_batch, valid_targets_lengths, valid_sources_lengths) = next(get_batches(valid_target, valid_source, batch_size,
source_letter_to_int['<PAD>'],
target_letter_to_int['<PAD>']))
display_step = 20 # Check training loss after every 20 batches
checkpoint = "best_model.ckpt"
with tf.Session(graph=train_graph) as sess:
sess.run(tf.global_variables_initializer())
for epoch_i in range(1, epochs+1):
for batch_i, (targets_batch, sources_batch, targets_lengths, sources_lengths) in enumerate(
get_batches(train_target, train_source, batch_size,
source_letter_to_int['<PAD>'],
target_letter_to_int['<PAD>'])):
# Training step
_, loss = sess.run(
[train_op, cost],
{input_data: sources_batch,
targets: targets_batch,
lr: learning_rate,
target_sequence_length: targets_lengths,
source_sequence_length: sources_lengths})
# Debug message updating us on the status of the training
if batch_i % display_step == 0 and batch_i > 0:
# Calculate validation cost
validation_loss = sess.run(
[cost],
{input_data: valid_sources_batch,
targets: valid_targets_batch,
lr: learning_rate,
target_sequence_length: valid_targets_lengths,
source_sequence_length: valid_sources_lengths})
print('Epoch {:>3}/{} Batch {:>4}/{} - Loss: {:>6.3f} - Validation loss: {:>6.3f}'
.format(epoch_i,
epochs,
batch_i,
len(train_source) // batch_size,
loss,
validation_loss[0]))
# Save Model
saver = tf.train.Saver()
saver.save(sess, checkpoint)
print('Model Trained and Saved')
Explanation: Train
We're now ready to train our model. If you run into OOM (out of memory) issues during training, try to decrease the batch_size.
End of explanation
def source_to_seq(text):
'''Prepare the text for the model'''
sequence_length = 7
return [source_letter_to_int.get(word, source_letter_to_int['<UNK>']) for word in text]+ [source_letter_to_int['<PAD>']]*(sequence_length-len(text))
input_sentence = 'hello'
text = source_to_seq(input_sentence)
checkpoint = "./best_model.ckpt"
loaded_graph = tf.Graph()
with tf.Session(graph=loaded_graph) as sess:
# Load saved model
loader = tf.train.import_meta_graph(checkpoint + '.meta')
loader.restore(sess, checkpoint)
input_data = loaded_graph.get_tensor_by_name('input:0')
logits = loaded_graph.get_tensor_by_name('predictions:0')
source_sequence_length = loaded_graph.get_tensor_by_name('source_sequence_length:0')
target_sequence_length = loaded_graph.get_tensor_by_name('target_sequence_length:0')
#Multiply by batch_size to match the model's input parameters
answer_logits = sess.run(logits, {input_data: [text]*batch_size,
target_sequence_length: [len(text)]*batch_size,
source_sequence_length: [len(text)]*batch_size})[0]
pad = source_letter_to_int["<PAD>"]
print('Original Text:', input_sentence)
print('\nSource')
print(' Word Ids: {}'.format([i for i in text]))
print(' Input Words: {}'.format(" ".join([source_int_to_letter[i] for i in text])))
print('\nTarget')
print(' Word Ids: {}'.format([i for i in answer_logits if i != pad]))
print(' Response Words: {}'.format(" ".join([target_int_to_letter[i] for i in answer_logits if i != pad])))
Explanation: Prediction
End of explanation |
3,499 | Given the following text description, write Python code to implement the functionality described below step by step
Description:
Module 6
Step1: This dataset is about the relationships between income and religion, assembled from a research by the Pew Research Center. You can read more details here. Is this dataset tidy or not? Why?
Yes, many of the columns are values, not variable names. How should we fix it?
Pandas provides a convenient function called melt. You specify the id_vars that are variable columns, and value_vars that are value columns, and provide the name for the variable as well as the name for the values.
Q
Step2: If you were successful, you'll have something like this
Step3: Data types
Let's talk about data types briefly. Understanding data types is not only important for choosing the right visualizations, but also important for efficient computing and storage of data. You may not have thought about how pandas represent data in memory. A Pandas Dataframe is essentially a bunch of Series, and those Series are essentially numpy arrays. An array may contain a fixed-length items such as integers or variable length items such as strings. Putting some efforts to think about the correct data type can potentially save a lot of memory as well as time.
A nice example would be the categorical data type. If you have a variable that only has several possible values, it's essentially a categorical data. Take a look at the income variable.
Step4: These were the column names in the original non-tidy data. The value can take only one of these income ranges and thus it is a categorical data. What is the data type that pandas use to store this column?
Step5: The O means that it is an object data type, which does not have a fixed size like integer or float. The series contains a sort of pointer to the actual text objects. You can actually inspect the amount of memory used by the dataset.
Step6: What's going on with the deep=True option? When you don't specify deep=True, the memory usage method just tells you the amount of memory used by the numpy arrays in the pandas dataframe. When you pass deep=True, it tells you the total amount of memory by including the memory used by all the text objects. So, the religion and income columns occupies almost ten times of memory than the frequency column, which is simply an array of integers.
Step7: Is there any way to save up the memory? Note that there are only 10 categories in the income variable. That means we just need 10 numbers to represent the categories! Of course we need to store the names of each category, but that's just one-time cost. The simplest way to convert a column is using astype method.
Step8: Now, this series has the CategoricalDtype dtype.
Step9: How much memory do we use?
Step10: We have reduced the memory usage by almost 10 fold! Not only that, because now the values are just numbers, it will be much faster to match, filter, manipulate. If your dataset is huge, this can save up a lot of space and time.
If the categories have ordering, you can specify the ordering too.
Step11: This data type now allows you to compare and sort based on the ordering.
Q | Python Code:
import pandas as pd
pew_df = pd.read_csv('https://raw.githubusercontent.com/tidyverse/tidyr/4c0a8d0fdb9372302fcc57ad995d57a43d9e4337/vignettes/pew.csv')
pew_df
Explanation: Module 6: Data types and tidy data
Tidy data
Let's do some tidy exercise first. This is one of the non-tidy dataset assembled by Hadley Wickham (check out here for more datasets, explanation, and R code).
Let's take a look at this small dataset: https://raw.githubusercontent.com/tidyverse/tidyr/4c0a8d0fdb9372302fcc57ad995d57a43d9e4337/vignettes/pew.csv
End of explanation
# TODO: Replace the dummy value of pew_tidy_df and put your code here.
pew_tidy_df = pd.DataFrame({"religion": ["ABCD" for i in range(15)],
"income": ["1k" for i in range(15)],
"frequency": [i for i in range(15)]})
Explanation: This dataset is about the relationships between income and religion, assembled from a research by the Pew Research Center. You can read more details here. Is this dataset tidy or not? Why?
Yes, many of the columns are values, not variable names. How should we fix it?
Pandas provides a convenient function called melt. You specify the id_vars that are variable columns, and value_vars that are value columns, and provide the name for the variable as well as the name for the values.
Q: so please go ahead and tidy it up! I'd suggest to use the variable name "income" and value name "frequency"
End of explanation
pew_tidy_df.sample(10)
Explanation: If you were successful, you'll have something like this:
End of explanation
pew_tidy_df.income.value_counts()
Explanation: Data types
Let's talk about data types briefly. Understanding data types is not only important for choosing the right visualizations, but also important for efficient computing and storage of data. You may not have thought about how pandas represent data in memory. A Pandas Dataframe is essentially a bunch of Series, and those Series are essentially numpy arrays. An array may contain a fixed-length items such as integers or variable length items such as strings. Putting some efforts to think about the correct data type can potentially save a lot of memory as well as time.
A nice example would be the categorical data type. If you have a variable that only has several possible values, it's essentially a categorical data. Take a look at the income variable.
End of explanation
pew_tidy_df.income.dtype
Explanation: These were the column names in the original non-tidy data. The value can take only one of these income ranges and thus it is a categorical data. What is the data type that pandas use to store this column?
End of explanation
pew_tidy_df.memory_usage()
pew_tidy_df.memory_usage(deep=True)
Explanation: The O means that it is an object data type, which does not have a fixed size like integer or float. The series contains a sort of pointer to the actual text objects. You can actually inspect the amount of memory used by the dataset.
End of explanation
pew_tidy_df.frequency.dtype
Explanation: What's going on with the deep=True option? When you don't specify deep=True, the memory usage method just tells you the amount of memory used by the numpy arrays in the pandas dataframe. When you pass deep=True, it tells you the total amount of memory by including the memory used by all the text objects. So, the religion and income columns occupies almost ten times of memory than the frequency column, which is simply an array of integers.
End of explanation
income_categorical_series = pew_tidy_df.income.astype('category')
# you can do pew_tidy_df.income = pew_tidy_df.income.astype('category')
Explanation: Is there any way to save up the memory? Note that there are only 10 categories in the income variable. That means we just need 10 numbers to represent the categories! Of course we need to store the names of each category, but that's just one-time cost. The simplest way to convert a column is using astype method.
End of explanation
income_categorical_series.dtype
Explanation: Now, this series has the CategoricalDtype dtype.
End of explanation
income_categorical_series.memory_usage(deep=True)
pew_tidy_df.income.memory_usage(deep=True)
Explanation: How much memory do we use?
End of explanation
from pandas.api.types import CategoricalDtype
income_type = CategoricalDtype(categories=["Don't know/refused", '<$10k', '$10-20k', '$20-30k', '$30-40k',
'$40-50k', '$50-75k', '$75-100k', '$100-150k', '>150k'], ordered=True)
income_type
pew_tidy_df.income.astype(income_type).dtype
Explanation: We have reduced the memory usage by almost 10 fold! Not only that, because now the values are just numbers, it will be much faster to match, filter, manipulate. If your dataset is huge, this can save up a lot of space and time.
If the categories have ordering, you can specify the ordering too.
End of explanation
# TODO: put your code here
Explanation: This data type now allows you to compare and sort based on the ordering.
Q: ok, now convert both religion and income columns of pew_tidy_df as categorical dtype (in place) and show that pew_tidy_df now uses much less memory
End of explanation |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.