From d61f96f83b51b84c03989d4fb166e36c10d2ffe7 Mon Sep 17 00:00:00 2001 From: Morten Hjorth-Jensen Date: Sat, 23 Oct 2021 21:54:01 +0200 Subject: [PATCH] cleaning week43 --- doc/pub/week43/html/._week43-bs000.html | 20 +- doc/pub/week43/html/._week43-bs001.html | 19 +- doc/pub/week43/html/._week43-bs002.html | 40 +-- doc/pub/week43/html/._week43-bs003.html | 40 ++- doc/pub/week43/html/._week43-bs004.html | 92 +---- doc/pub/week43/html/._week43-bs005.html | 108 ++++-- doc/pub/week43/html/._week43-bs006.html | 154 +++------ doc/pub/week43/html/._week43-bs007.html | 202 ++++++----- doc/pub/week43/html/._week43-bs008.html | 120 ++++--- doc/pub/week43/html/._week43-bs009.html | 202 +++-------- doc/pub/week43/html/._week43-bs010.html | 342 ++++++++++++------- doc/pub/week43/html/week43-bs.html | 20 +- doc/pub/week43/html/week43-reveal.html | 8 + doc/pub/week43/html/week43-solarized.html | 9 + doc/pub/week43/html/week43.html | 9 + doc/pub/week43/ipynb/ipynb-week43-src.tar.gz | Bin 192 -> 190 bytes doc/pub/week43/ipynb/week43.ipynb | 3 + doc/src/week43/week43.do.txt | 4 + 18 files changed, 674 insertions(+), 718 deletions(-) diff --git a/doc/pub/week43/html/._week43-bs000.html b/doc/pub/week43/html/._week43-bs000.html index 84c0a6a3d..60a56a623 100644 --- a/doc/pub/week43/html/._week43-bs000.html +++ b/doc/pub/week43/html/._week43-bs000.html @@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source Contents @@ -146,6 +148,8 @@ end of tocinfo -->
  • 8
  • 9
  • 10
    • +
  • ...
    • +
  • 11
  • »
    • diff --git a/doc/pub/week43/html/._week43-bs001.html b/doc/pub/week43/html/._week43-bs001.html index 55833313f..5237b40e7 100644 --- a/doc/pub/week43/html/._week43-bs001.html +++ b/doc/pub/week43/html/._week43-bs001.html @@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source Contents @@ -152,6 +154,7 @@ end of tocinfo -->
  • 8
  • 9
  • 10
    • +
  • 11
  • »
    • diff --git a/doc/pub/week43/html/._week43-bs002.html b/doc/pub/week43/html/._week43-bs002.html index ba24468d6..10f85bc53 100644 --- a/doc/pub/week43/html/._week43-bs002.html +++ b/doc/pub/week43/html/._week43-bs002.html @@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source Contents @@ -104,27 +106,10 @@ end of tocinfo --> -

    Recurrent neural networks: Overarching view

    +

    Summary on CNNs

    -Till now our focus has been, including convolutional neural networks -as well, on feedforward neural networks. The output or the activations -flow only in one direction, from the input layer to the output layer. - -

    -A recurrent neural network (RNN) looks very much like a feedforward -neural network, except that it also has connections pointing -backward. - -

    -RNNs are used to analyze time series data such as stock prices, and -tell you when to buy or sell. In autonomous driving systems, they can -anticipate car trajectories and help avoid accidents. More generally, -they can work on sequences of arbitrary lengths, rather than on -fixed-sized inputs like all the nets we have discussed so far. For -example, they can take sentences, documents, or audio samples as -input, making them extremely useful for natural language processing -systems such as automatic translation and speech-to-text. +Material to be added

    @@ -141,6 +126,7 @@ systems such as automatic translation and speech-to-text.

  • 8
  • 9
  • 10
    • +
  • 11
  • »
    • diff --git a/doc/pub/week43/html/._week43-bs003.html b/doc/pub/week43/html/._week43-bs003.html index a842ce005..8793a06ae 100644 --- a/doc/pub/week43/html/._week43-bs003.html +++ b/doc/pub/week43/html/._week43-bs003.html @@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source Contents @@ -104,10 +106,27 @@ end of tocinfo --> -

    Set up of an RNN

    +

    Recurrent neural networks: Overarching view

    -Text to come. +Till now our focus has been, including convolutional neural networks +as well, on feedforward neural networks. The output or the activations +flow only in one direction, from the input layer to the output layer. + +

    +A recurrent neural network (RNN) looks very much like a feedforward +neural network, except that it also has connections pointing +backward. + +

    +RNNs are used to analyze time series data such as stock prices, and +tell you when to buy or sell. In autonomous driving systems, they can +anticipate car trajectories and help avoid accidents. More generally, +they can work on sequences of arbitrary lengths, rather than on +fixed-sized inputs like all the nets we have discussed so far. For +example, they can take sentences, documents, or audio samples as +input, making them extremely useful for natural language processing +systems such as automatic translation and speech-to-text.

    @@ -124,6 +143,7 @@ Text to come.

  • 8
  • 9
  • 10
    • +
  • 11
  • »
    • diff --git a/doc/pub/week43/html/._week43-bs004.html b/doc/pub/week43/html/._week43-bs004.html index b505b8372..a232da506 100644 --- a/doc/pub/week43/html/._week43-bs004.html +++ b/doc/pub/week43/html/._week43-bs004.html @@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source Contents @@ -104,80 +106,11 @@ end of tocinfo --> -

    A simple example

    +

    Set up of an RNN

    +Text to come. - -

    # Start importing packages
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import tensorflow as tf
-from tensorflow.keras import datasets, layers, models
-from tensorflow.keras.layers import Input
-from tensorflow.keras.models import Model, Sequential 
-from tensorflow.keras.layers import Dense, SimpleRNN, LSTM, GRU
-from tensorflow.keras import optimizers     
-from tensorflow.keras import regularizers           
-from tensorflow.keras.utils import to_categorical 
-
-
-
-# convert into dataset matrix
-def convertToMatrix(data, step):
- X, Y =[], []
- for i in range(len(data)-step):
-  d=i+step  
-  X.append(data[i:d,])
-  Y.append(data[d,])
- return np.array(X), np.array(Y)
-
-step = 4
-N = 1000    
-Tp = 800    
-
-t=np.arange(0,N)
-x=np.sin(0.02*t)+2*np.random.rand(N)
-df = pd.DataFrame(x)
-df.head()
-
-plt.plot(df)
-plt.show()
-
-values=df.values
-train,test = values[0:Tp,:], values[Tp:N,:]
-
-# add step elements into train and test
-test = np.append(test,np.repeat(test[-1,],step))
-train = np.append(train,np.repeat(train[-1,],step))
- 
-trainX,trainY =convertToMatrix(train,step)
-testX,testY =convertToMatrix(test,step)
-trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
-testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
-
-model = Sequential()
-model.add(SimpleRNN(units=32, input_shape=(1,step), activation="relu"))
-model.add(Dense(8, activation="relu")) 
-model.add(Dense(1))
-model.compile(loss='mean_squared_error', optimizer='rmsprop')
-model.summary()
-
-model.fit(trainX,trainY, epochs=100, batch_size=16, verbose=2)
-trainPredict = model.predict(trainX)
-testPredict= model.predict(testX)
-predicted=np.concatenate((trainPredict,testPredict),axis=0)
-
-trainScore = model.evaluate(trainX, trainY, verbose=0)
-print(trainScore)
-
-index = df.index.values
-plt.plot(index,df)
-plt.plot(index,predicted)
-plt.axvline(df.index[Tp], c="r")
-plt.show()
-

    @@ -193,6 +126,7 @@ plt.show()

  • 8
  • 9
  • 10
    • +
  • 11
  • »
    • diff --git a/doc/pub/week43/html/._week43-bs005.html b/doc/pub/week43/html/._week43-bs005.html index 94d19a78f..8e27f8304 100644 --- a/doc/pub/week43/html/._week43-bs005.html +++ b/doc/pub/week43/html/._week43-bs005.html @@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source Contents @@ -104,44 +106,79 @@ end of tocinfo --> -

    An extrapolation example

    - -

    -The following code provides an example of how recurrent neural -networks can be used to extrapolate to unknown values of physics data -sets. Specifically, the data sets used in this program come from -a quantum mechanical many-body calculation of energies as functions of the number of particles. +

    A simple example

    -

    # For matrices and calculations
+
    # Start importing packages
+import pandas as pd
 import numpy as np
-# For machine learning (backend for keras)
+import matplotlib.pyplot as plt
 import tensorflow as tf
-# User-friendly machine learning library
-# Front end for TensorFlow
-import tensorflow.keras
-# Different methods from Keras needed to create an RNN
-# This is not necessary but it shortened function calls 
-# that need to be used in the code.
 from tensorflow.keras import datasets, layers, models
 from tensorflow.keras.layers import Input
-from tensorflow.keras import regularizers
-from tensorflow.keras.models import Model, Sequential
+from tensorflow.keras.models import Model, Sequential 
 from tensorflow.keras.layers import Dense, SimpleRNN, LSTM, GRU
-# For timing the code
-from timeit import default_timer as timer
-# For plotting
-import matplotlib.pyplot as plt
+from tensorflow.keras import optimizers     
+from tensorflow.keras import regularizers           
+from tensorflow.keras.utils import to_categorical 
 
 
-# The data set
-datatype='VaryDimension'
-X_tot = np.arange(2, 42, 2)
-y_tot = np.array([-0.03077640549, -0.08336233266, -0.1446729567, -0.2116753732, -0.2830637392, -0.3581341341, -0.436462435, -0.5177783846,
-	-0.6019067271, -0.6887363571, -0.7782028952, -0.8702784034, -0.9649652536, -1.062292565, -1.16231451, 
-	-1.265109911, -1.370782966, -1.479465113, -1.591317992, -1.70653767])
+
+# convert into dataset matrix
+def convertToMatrix(data, step):
+ X, Y =[], []
+ for i in range(len(data)-step):
+  d=i+step  
+  X.append(data[i:d,])
+  Y.append(data[d,])
+ return np.array(X), np.array(Y)
+
+step = 4
+N = 1000    
+Tp = 800    
+
+t=np.arange(0,N)
+x=np.sin(0.02*t)+2*np.random.rand(N)
+df = pd.DataFrame(x)
+df.head()
+
+plt.plot(df)
+plt.show()
+
+values=df.values
+train,test = values[0:Tp,:], values[Tp:N,:]
+
+# add step elements into train and test
+test = np.append(test,np.repeat(test[-1,],step))
+train = np.append(train,np.repeat(train[-1,],step))
+ 
+trainX,trainY =convertToMatrix(train,step)
+testX,testY =convertToMatrix(test,step)
+trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
+testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
+
+model = Sequential()
+model.add(SimpleRNN(units=32, input_shape=(1,step), activation="relu"))
+model.add(Dense(8, activation="relu")) 
+model.add(Dense(1))
+model.compile(loss='mean_squared_error', optimizer='rmsprop')
+model.summary()
+
+model.fit(trainX,trainY, epochs=100, batch_size=16, verbose=2)
+trainPredict = model.predict(trainX)
+testPredict= model.predict(testX)
+predicted=np.concatenate((trainPredict,testPredict),axis=0)
+
+trainScore = model.evaluate(trainX, trainY, verbose=0)
+print(trainScore)
+
+index = df.index.values
+plt.plot(index,df)
+plt.plot(index,predicted)
+plt.axvline(df.index[Tp], c="r")
+plt.show()
 
    
 
    
 
    
@@ -158,6 +195,7 @@ y_tot = np.8
   
  • 9
    • 
   
  • 10
    • 
+  
  • 11
    • 
   
  • »
    • 
 
 
diff --git a/doc/pub/week43/html/._week43-bs006.html b/doc/pub/week43/html/._week43-bs006.html
index 98333957b..67e6a5763 100644
--- a/doc/pub/week43/html/._week43-bs006.html
+++ b/doc/pub/week43/html/._week43-bs006.html
@@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source
 
         Contents 
         
       
@@ -104,119 +106,44 @@ end of tocinfo -->
 
 
 
-
    Formatting the Data 
    
+
    An extrapolation example 
    
 
 
    
-The way the recurrent neural networks are trained in this program
-differs from how machine learning algorithms are usually trained.
-Typically a machine learning algorithm is trained by learning the
-relationship between the x data and the y data.  In this program, the
-recurrent neural network will be trained to recognize the relationship
-in a sequence of y values.  This is type of data formatting is
-typically used time series forcasting, but it can also be used in any
-extrapolation (time series forecasting is just a specific type of
-extrapolation along the time axis).  This method of data formatting
-does not use the x data and assumes that the y data are evenly spaced.
-
-
    
-For a standard machine learning algorithm, the training data has the
-form of (x,y) so the machine learning algorithm learns to assiciate a
-y value with a given x value.  This is useful when the test data has x
-values within the same range as the training data.  However, for this
-application, the x values of the test data are outside of the x values
-of the training data and the traditional method of training a machine
-learning algorithm does not work as well.  For this reason, the
-recurrent neural network is trained on sequences of y values of the
-form ((y1, y2), y3), so that the network is concerned with learning
-the pattern of the y data and not the relation between the x and y
-data.  As long as the pattern of y data outside of the training region
-stays relatively stable compared to what was inside the training
-region, this method of training can produce accurate extrapolations to
-y values far removed from the training data set.
-
-
    
-
-
-
-
-
-
+The following code provides an example of how recurrent neural
+networks can be used to extrapolate to unknown values of physics data
+sets.  Specifically, the data sets used in this program come from
+a quantum mechanical many-body calculation of energies as functions of the number of particles.
 
 
    
 
 
-
    # FORMAT_DATA
-def format_data(data, length_of_sequence = 2):  
-    """
-        Inputs:
-            data(a numpy array): the data that will be the inputs to the recurrent neural
-                network
-            length_of_sequence (an int): the number of elements in one iteration of the
-                sequence patter.  For a function approximator use length_of_sequence = 2.
-        Returns:
-            rnn_input (a 3D numpy array): the input data for the recurrent neural network.  Its
-                dimensions are length of data - length of sequence, length of sequence, 
-                dimnsion of data
-            rnn_output (a numpy array): the training data for the neural network
-        Formats data to be used in a recurrent neural network.
-    """
-
-    X, Y = [], []
-    for i in range(len(data)-length_of_sequence):
-        # Get the next length_of_sequence elements
-        a = data[i:i+length_of_sequence]
-        # Get the element that immediately follows that
-        b = data[i+length_of_sequence]
-        # Reshape so that each data point is contained in its own array
-        a = np.reshape (a, (len(a), 1))
-        X.append(a)
-        Y.append(b)
-    rnn_input = np.array(X)
-    rnn_output = np.array(Y)
-
-    return rnn_input, rnn_output
+
    # For matrices and calculations
+import numpy as np
+# For machine learning (backend for keras)
+import tensorflow as tf
+# User-friendly machine learning library
+# Front end for TensorFlow
+import tensorflow.keras
+# Different methods from Keras needed to create an RNN
+# This is not necessary but it shortened function calls 
+# that need to be used in the code.
+from tensorflow.keras import datasets, layers, models
+from tensorflow.keras.layers import Input
+from tensorflow.keras import regularizers
+from tensorflow.keras.models import Model, Sequential
+from tensorflow.keras.layers import Dense, SimpleRNN, LSTM, GRU
+# For timing the code
+from timeit import default_timer as timer
+# For plotting
+import matplotlib.pyplot as plt
 
 
-# ## Defining the Recurrent Neural Network Using Keras
-# 
-# The following method defines a simple recurrent neural network in keras consisting of one input layer, one hidden layer, and one output layer.
-
-def rnn(length_of_sequences, batch_size = None, stateful = False):
-    """
-        Inputs:
-            length_of_sequences (an int): the number of y values in "x data".  This is determined
-                when the data is formatted
-            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.
-            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.
-        Returns:
-            model (a Keras model): The recurrent neural network that is built and compiled by this
-                method
-        Builds and compiles a recurrent neural network with one hidden layer and returns the model.
-    """
-    # Number of neurons in the input and output layers
-    in_out_neurons = 1
-    # Number of neurons in the hidden layer
-    hidden_neurons = 200
-    # Define the input layer
-    inp = Input(batch_shape=(batch_size, 
-                length_of_sequences, 
-                in_out_neurons))  
-    # Define the hidden layer as a simple RNN layer with a set number of neurons and add it to 
-    # the network immediately after the input layer
-    rnn = SimpleRNN(hidden_neurons, 
-                    return_sequences=False,
-                    stateful = stateful,
-                    name="RNN")(inp)
-    # Define the output layer as a dense neural network layer (standard neural network layer)
-    #and add it to the network immediately after the hidden layer.
-    dens = Dense(in_out_neurons,name="dense")(rnn)
-    # Create the machine learning model starting with the input layer and ending with the 
-    # output layer
-    model = Model(inputs=[inp],outputs=[dens])
-    # Compile the machine learning model using the mean squared error function as the loss 
-    # function and an Adams optimizer.
-    model.compile(loss="mean_squared_error", optimizer="adam")  
-    return model
+# The data set
+datatype='VaryDimension'
+X_tot = np.arange(2, 42, 2)
+y_tot = np.array([-0.03077640549, -0.08336233266, -0.1446729567, -0.2116753732, -0.2830637392, -0.3581341341, -0.436462435, -0.5177783846,
+	-0.6019067271, -0.6887363571, -0.7782028952, -0.8702784034, -0.9649652536, -1.062292565, -1.16231451, 
+	-1.265109911, -1.370782966, -1.479465113, -1.591317992, -1.70653767])
 
    
 
    
 
    
@@ -233,6 +160,7 @@ y values far removed from the training data set.
   
  • 8
    • 
   
  • 9
    • 
   
  • 10
    • 
+  
  • 11
    • 
   
  • »
    • 
 
 
diff --git a/doc/pub/week43/html/._week43-bs007.html b/doc/pub/week43/html/._week43-bs007.html
index 32462c068..882c226c9 100644
--- a/doc/pub/week43/html/._week43-bs007.html
+++ b/doc/pub/week43/html/._week43-bs007.html
@@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source
 
         Contents 
         
       
@@ -104,102 +106,119 @@ end of tocinfo -->
 
 
 
-
    Predicting New Points With A Trained Recurrent Neural Network 
    
+
    Formatting the Data 
    
+
+
    
+The way the recurrent neural networks are trained in this program
+differs from how machine learning algorithms are usually trained.
+Typically a machine learning algorithm is trained by learning the
+relationship between the x data and the y data.  In this program, the
+recurrent neural network will be trained to recognize the relationship
+in a sequence of y values.  This is type of data formatting is
+typically used time series forcasting, but it can also be used in any
+extrapolation (time series forecasting is just a specific type of
+extrapolation along the time axis).  This method of data formatting
+does not use the x data and assumes that the y data are evenly spaced.
+
+
    
+For a standard machine learning algorithm, the training data has the
+form of (x,y) so the machine learning algorithm learns to assiciate a
+y value with a given x value.  This is useful when the test data has x
+values within the same range as the training data.  However, for this
+application, the x values of the test data are outside of the x values
+of the training data and the traditional method of training a machine
+learning algorithm does not work as well.  For this reason, the
+recurrent neural network is trained on sequences of y values of the
+form ((y1, y2), y3), so that the network is concerned with learning
+the pattern of the y data and not the relation between the x and y
+data.  As long as the pattern of y data outside of the training region
+stays relatively stable compared to what was inside the training
+region, this method of training can produce accurate extrapolations to
+y values far removed from the training data set.
+
+
    
+
+
+
+
+
+
 
 
    
 
 
-
    def test_rnn (x1, y_test, plot_min, plot_max):
+
    # FORMAT_DATA
+def format_data(data, length_of_sequence = 2):  
     """
         Inputs:
-            x1 (a list or numpy array): The complete x component of the data set
-            y_test (a list or numpy array): The complete y component of the data set
-            plot_min (an int or float): the smallest x value used in the training data
-            plot_max (an int or float): the largest x valye used in the training data
+            data(a numpy array): the data that will be the inputs to the recurrent neural
+                network
+            length_of_sequence (an int): the number of elements in one iteration of the
+                sequence patter.  For a function approximator use length_of_sequence = 2.
         Returns:
-            None.
-        Uses a trained recurrent neural network model to predict future points in the 
-        series.  Computes the MSE of the predicted data set from the true data set, saves
-        the predicted data set to a csv file, and plots the predicted and true data sets w
-        while also displaying the data range used for training.
+            rnn_input (a 3D numpy array): the input data for the recurrent neural network.  Its
+                dimensions are length of data - length of sequence, length of sequence, 
+                dimnsion of data
+            rnn_output (a numpy array): the training data for the neural network
+        Formats data to be used in a recurrent neural network.
     """
-    # Add the training data as the first dim points in the predicted data array as these
-    # are known values.
-    y_pred = y_test[:dim].tolist()
-    # Generate the first input to the trained recurrent neural network using the last two 
-    # points of the training data.  Based on how the network was trained this means that it
-    # will predict the first point in the data set after the training data.  All of the 
-    # brackets are necessary for Tensorflow.
-    next_input = np.array([[[y_test[dim-2]], [y_test[dim-1]]]])
-    # Save the very last point in the training data set.  This will be used later.
-    last = [y_test[dim-1]]
 
-    # Iterate until the complete data set is created.
-    for i in range (dim, len(y_test)):
-        # Predict the next point in the data set using the previous two points.
-        next = model.predict(next_input)
-        # Append just the number of the predicted data set
-        y_pred.append(next[0][0])
-        # Create the input that will be used to predict the next data point in the data set.
-        next_input = np.array([[last, next[0]]], dtype=np.float64)
-        last = next
+    X, Y = [], []
+    for i in range(len(data)-length_of_sequence):
+        # Get the next length_of_sequence elements
+        a = data[i:i+length_of_sequence]
+        # Get the element that immediately follows that
+        b = data[i+length_of_sequence]
+        # Reshape so that each data point is contained in its own array
+        a = np.reshape (a, (len(a), 1))
+        X.append(a)
+        Y.append(b)
+    rnn_input = np.array(X)
+    rnn_output = np.array(Y)
 
-    # Print the mean squared error between the known data set and the predicted data set.
-    print('MSE: ', np.square(np.subtract(y_test, y_pred)).mean())
-    # Save the predicted data set as a csv file for later use
-    name = datatype + 'Predicted'+str(dim)+'.csv'
-    np.savetxt(name, y_pred, delimiter=',')
-    # Plot the known data set and the predicted data set.  The red box represents the region that was used
-    # for the training data.
-    fig, ax = plt.subplots()
-    ax.plot(x1, y_test, label="true", linewidth=3)
-    ax.plot(x1, y_pred, 'g-.',label="predicted", linewidth=4)
-    ax.legend()
-    # Created a red region to represent the points used in the training data.
-    ax.axvspan(plot_min, plot_max, alpha=0.25, color='red')
-    plt.show()
-
-# Check to make sure the data set is complete
-assert len(X_tot) == len(y_tot)
-
-# This is the number of points that will be used in as the training data
-dim=12
-
-# Separate the training data from the whole data set
-X_train = X_tot[:dim]
-y_train = y_tot[:dim]
+    return rnn_input, rnn_output
 
 
-# Generate the training data for the RNN, using a sequence of 2
-rnn_input, rnn_training = format_data(y_train, 2)
+# ## Defining the Recurrent Neural Network Using Keras
+# 
+# The following method defines a simple recurrent neural network in keras consisting of one input layer, one hidden layer, and one output layer.
 
-
-# Create a recurrent neural network in Keras and produce a summary of the 
-# machine learning model
-model = rnn(length_of_sequences = rnn_input.shape[1])
-model.summary()
-
-# Start the timer.  Want to time training+testing
-start = timer()
-# Fit the model using the training data genenerated above using 150 training iterations and a 5%
-# validation split.  Setting verbose to True prints information about each training iteration.
-hist = model.fit(rnn_input, rnn_training, batch_size=None, epochs=150, 
-                 verbose=True,validation_split=0.05)
-
-for label in ["loss","val_loss"]:
-    plt.plot(hist.history[label],label=label)
-
-plt.ylabel("loss")
-plt.xlabel("epoch")
-plt.title("The final validation loss: {}".format(hist.history["val_loss"][-1]))
-plt.legend()
-plt.show()
-
-# Use the trained neural network to predict more points of the data set
-test_rnn(X_tot, y_tot, X_tot[0], X_tot[dim-1])
-# Stop the timer and calculate the total time needed.
-end = timer()
-print('Time: ', end-start)
+def rnn(length_of_sequences, batch_size = None, stateful = False):
+    """
+        Inputs:
+            length_of_sequences (an int): the number of y values in "x data".  This is determined
+                when the data is formatted
+            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.
+            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.
+        Returns:
+            model (a Keras model): The recurrent neural network that is built and compiled by this
+                method
+        Builds and compiles a recurrent neural network with one hidden layer and returns the model.
+    """
+    # Number of neurons in the input and output layers
+    in_out_neurons = 1
+    # Number of neurons in the hidden layer
+    hidden_neurons = 200
+    # Define the input layer
+    inp = Input(batch_shape=(batch_size, 
+                length_of_sequences, 
+                in_out_neurons))  
+    # Define the hidden layer as a simple RNN layer with a set number of neurons and add it to 
+    # the network immediately after the input layer
+    rnn = SimpleRNN(hidden_neurons, 
+                    return_sequences=False,
+                    stateful = stateful,
+                    name="RNN")(inp)
+    # Define the output layer as a dense neural network layer (standard neural network layer)
+    #and add it to the network immediately after the hidden layer.
+    dens = Dense(in_out_neurons,name="dense")(rnn)
+    # Create the machine learning model starting with the input layer and ending with the 
+    # output layer
+    model = Model(inputs=[inp],outputs=[dens])
+    # Compile the machine learning model using the mean squared error function as the loss 
+    # function and an Adams optimizer.
+    model.compile(loss="mean_squared_error", optimizer="adam")  
+    return model
 
    
 
    
 
    
@@ -216,6 +235,7 @@ end = timer()
   
  • 8
    • 
   
  • 9
    • 
   
  • 10
    • 
+  
  • 11
    • 
   
  • »
    • 
 
 
diff --git a/doc/pub/week43/html/._week43-bs008.html b/doc/pub/week43/html/._week43-bs008.html
index 7e0b7747a..2b61d4365 100644
--- a/doc/pub/week43/html/._week43-bs008.html
+++ b/doc/pub/week43/html/._week43-bs008.html
@@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source
 
         Contents 
         
       
@@ -104,63 +106,60 @@ end of tocinfo -->
 
 
 
-
    Other Things to Try 
    
-
-
    
-Changing the size of the recurrent neural network and its parameters
-can drastically change the results you get from the model.  The below
-code takes the simple recurrent neural network from above and adds a
-second hidden layer, changes the number of neurons in the hidden
-layer, and explicitly declares the activation function of the hidden
-layers to be a sigmoid function.  The loss function and optimizer can
-also be changed but are kept the same as the above network.  These
-parameters can be tuned to provide the optimal result from the
-network.  For some ideas on how to improve the performance of a
-recurrent neural network.
+
    Predicting New Points With A Trained Recurrent Neural Network 
    
 
 
    
 
 
-
    def rnn_2layers(length_of_sequences, batch_size = None, stateful = False):
+
    def test_rnn (x1, y_test, plot_min, plot_max):
     """
         Inputs:
-            length_of_sequences (an int): the number of y values in "x data".  This is determined
-                when the data is formatted
-            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.
-            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.
+            x1 (a list or numpy array): The complete x component of the data set
+            y_test (a list or numpy array): The complete y component of the data set
+            plot_min (an int or float): the smallest x value used in the training data
+            plot_max (an int or float): the largest x valye used in the training data
         Returns:
-            model (a Keras model): The recurrent neural network that is built and compiled by this
-                method
-        Builds and compiles a recurrent neural network with two hidden layers and returns the model.
+            None.
+        Uses a trained recurrent neural network model to predict future points in the 
+        series.  Computes the MSE of the predicted data set from the true data set, saves
+        the predicted data set to a csv file, and plots the predicted and true data sets w
+        while also displaying the data range used for training.
     """
-    # Number of neurons in the input and output layers
-    in_out_neurons = 1
-    # Number of neurons in the hidden layer, increased from the first network
-    hidden_neurons = 500
-    # Define the input layer
-    inp = Input(batch_shape=(batch_size, 
-                length_of_sequences, 
-                in_out_neurons))  
-    # Create two hidden layers instead of one hidden layer.  Explicitly set the activation
-    # function to be the sigmoid function (the default value is hyperbolic tangent)
-    rnn1 = SimpleRNN(hidden_neurons, 
-                    return_sequences=True,  # This needs to be True if another hidden layer is to follow
-                    stateful = stateful, activation = 'sigmoid',
-                    name="RNN1")(inp)
-    rnn2 = SimpleRNN(hidden_neurons, 
-                    return_sequences=False, activation = 'sigmoid',
-                    stateful = stateful,
-                    name="RNN2")(rnn1)
-    # Define the output layer as a dense neural network layer (standard neural network layer)
-    #and add it to the network immediately after the hidden layer.
-    dens = Dense(in_out_neurons,name="dense")(rnn2)
-    # Create the machine learning model starting with the input layer and ending with the 
-    # output layer
-    model = Model(inputs=[inp],outputs=[dens])
-    # Compile the machine learning model using the mean squared error function as the loss 
-    # function and an Adams optimizer.
-    model.compile(loss="mean_squared_error", optimizer="adam")  
-    return model
+    # Add the training data as the first dim points in the predicted data array as these
+    # are known values.
+    y_pred = y_test[:dim].tolist()
+    # Generate the first input to the trained recurrent neural network using the last two 
+    # points of the training data.  Based on how the network was trained this means that it
+    # will predict the first point in the data set after the training data.  All of the 
+    # brackets are necessary for Tensorflow.
+    next_input = np.array([[[y_test[dim-2]], [y_test[dim-1]]]])
+    # Save the very last point in the training data set.  This will be used later.
+    last = [y_test[dim-1]]
+
+    # Iterate until the complete data set is created.
+    for i in range (dim, len(y_test)):
+        # Predict the next point in the data set using the previous two points.
+        next = model.predict(next_input)
+        # Append just the number of the predicted data set
+        y_pred.append(next[0][0])
+        # Create the input that will be used to predict the next data point in the data set.
+        next_input = np.array([[last, next[0]]], dtype=np.float64)
+        last = next
+
+    # Print the mean squared error between the known data set and the predicted data set.
+    print('MSE: ', np.square(np.subtract(y_test, y_pred)).mean())
+    # Save the predicted data set as a csv file for later use
+    name = datatype + 'Predicted'+str(dim)+'.csv'
+    np.savetxt(name, y_pred, delimiter=',')
+    # Plot the known data set and the predicted data set.  The red box represents the region that was used
+    # for the training data.
+    fig, ax = plt.subplots()
+    ax.plot(x1, y_test, label="true", linewidth=3)
+    ax.plot(x1, y_pred, 'g-.',label="predicted", linewidth=4)
+    ax.legend()
+    # Created a red region to represent the points used in the training data.
+    ax.axvspan(plot_min, plot_max, alpha=0.25, color='red')
+    plt.show()
 
 # Check to make sure the data set is complete
 assert len(X_tot) == len(y_tot)
@@ -179,7 +178,7 @@ rnn_input, rnn_training = format_data(y_trai
 
 # Create a recurrent neural network in Keras and produce a summary of the 
 # machine learning model
-model = rnn_2layers(length_of_sequences = 2)
+model = rnn(length_of_sequences = rnn_input.shape[1])
 model.summary()
 
 # Start the timer.  Want to time training+testing
@@ -189,10 +188,6 @@ start = timer()
 hist = model.fit(rnn_input, rnn_training, batch_size=None, epochs=150, 
                  verbose=True,validation_split=0.05)
 
-
-# This section plots the training loss and the validation loss as a function of training iteration.
-# This is not required for analyzing the couple cluster data but can help determine if the network is
-# being overtrained.
 for label in ["loss","val_loss"]:
     plt.plot(hist.history[label],label=label)
 
@@ -223,6 +218,7 @@ end = timer()
   
  • 8
    • 
   
  • 9
    • 
   
  • 10
    • 
+  
  • 11
    • 
   
  • »
    • 
 
 
diff --git a/doc/pub/week43/html/._week43-bs009.html b/doc/pub/week43/html/._week43-bs009.html
index 63e129f53..52b5bd2c7 100644
--- a/doc/pub/week43/html/._week43-bs009.html
+++ b/doc/pub/week43/html/._week43-bs009.html
@@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source
 
         Contents 
         
       
@@ -104,29 +106,24 @@ end of tocinfo -->
 
 
 
-
    Other Types of Recurrent Neural Networks 
    
+
    Other Things to Try 
    
 
 
    
-Besides a simple recurrent neural network layer, there are two other
-commonly used types of recurrent neural network layers: Long Short
-Term Memory (LSTM) and Gated Recurrent Unit (GRU).  For a short
-introduction to these layers see https://medium.com/mindboard/lstm-vs-gru-experimental-comparison-955820c21e8b
-and https://medium.com/mindboard/lstm-vs-gru-experimental-comparison-955820c21e8b.
-
-
    
-The first network created below is similar to the previous network,
-but it replaces the SimpleRNN layers with LSTM layers.  The second
-network below has two hidden layers made up of GRUs, which are
-preceeded by two dense (feeddorward) neural network layers.  These
-dense layers "preprocess" the data before it reaches the recurrent
-layers.  This architecture has been shown to improve the performance
-of recurrent neural networks (see the link above and also
-https://arxiv.org/pdf/1807.02857.pdf.
+Changing the size of the recurrent neural network and its parameters
+can drastically change the results you get from the model.  The below
+code takes the simple recurrent neural network from above and adds a
+second hidden layer, changes the number of neurons in the hidden
+layer, and explicitly declares the activation function of the hidden
+layers to be a sigmoid function.  The loss function and optimizer can
+also be changed but are kept the same as the above network.  These
+parameters can be tuned to provide the optimal result from the
+network.  For some ideas on how to improve the performance of a
+recurrent neural network.
 
 
    
 
 
-
    def lstm_2layers(length_of_sequences, batch_size = None, stateful = False):
+
    def rnn_2layers(length_of_sequences, batch_size = None, stateful = False):
     """
         Inputs:
             length_of_sequences (an int): the number of y values in "x data".  This is determined
@@ -136,72 +133,35 @@ of recurrent neural networks (see the link above and also
         Returns:
             model (a Keras model): The recurrent neural network that is built and compiled by this
                 method
-        Builds and compiles a recurrent neural network with two LSTM hidden layers and returns the model.
+        Builds and compiles a recurrent neural network with two hidden layers and returns the model.
     """
-    # Number of neurons on the input/output layer and the number of neurons in the hidden layer
+    # Number of neurons in the input and output layers
     in_out_neurons = 1
-    hidden_neurons = 250
-    # Input Layer
+    # Number of neurons in the hidden layer, increased from the first network
+    hidden_neurons = 500
+    # Define the input layer
     inp = Input(batch_shape=(batch_size, 
                 length_of_sequences, 
-                in_out_neurons)) 
-    # Hidden layers (in this case they are LSTM layers instead if SimpleRNN layers)
-    rnn= LSTM(hidden_neurons, 
-                    return_sequences=True,
+                in_out_neurons))  
+    # Create two hidden layers instead of one hidden layer.  Explicitly set the activation
+    # function to be the sigmoid function (the default value is hyperbolic tangent)
+    rnn1 = SimpleRNN(hidden_neurons, 
+                    return_sequences=True,  # This needs to be True if another hidden layer is to follow
+                    stateful = stateful, activation = 'sigmoid',
+                    name="RNN1")(inp)
+    rnn2 = SimpleRNN(hidden_neurons, 
+                    return_sequences=False, activation = 'sigmoid',
                     stateful = stateful,
-                    name="RNN", use_bias=True, activation='tanh')(inp)
-    rnn1 = LSTM(hidden_neurons, 
-                    return_sequences=False,
-                    stateful = stateful,
-                    name="RNN1", use_bias=True, activation='tanh')(rnn)
-    # Output layer
-    dens = Dense(in_out_neurons,name="dense")(rnn1)
-    # Define the midel
+                    name="RNN2")(rnn1)
+    # Define the output layer as a dense neural network layer (standard neural network layer)
+    #and add it to the network immediately after the hidden layer.
+    dens = Dense(in_out_neurons,name="dense")(rnn2)
+    # Create the machine learning model starting with the input layer and ending with the 
+    # output layer
     model = Model(inputs=[inp],outputs=[dens])
-    # Compile the model
-    model.compile(loss='mean_squared_error', optimizer='adam')  
-    # Return the model
-    return model
-
-def dnn2_gru2(length_of_sequences, batch_size = None, stateful = False):
-    """
-        Inputs:
-            length_of_sequences (an int): the number of y values in "x data".  This is determined
-                when the data is formatted
-            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.
-            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.
-        Returns:
-            model (a Keras model): The recurrent neural network that is built and compiled by this
-                method
-        Builds and compiles a recurrent neural network with four hidden layers (two dense followed by
-        two GRU layers) and returns the model.
-    """    
-    # Number of neurons on the input/output layers and hidden layers
-    in_out_neurons = 1
-    hidden_neurons = 250
-    # Input layer
-    inp = Input(batch_shape=(batch_size, 
-                length_of_sequences, 
-                in_out_neurons)) 
-    # Hidden Dense (feedforward) layers
-    dnn = Dense(hidden_neurons/2, activation='relu', name='dnn')(inp)
-    dnn1 = Dense(hidden_neurons/2, activation='relu', name='dnn1')(dnn)
-    # Hidden GRU layers
-    rnn1 = GRU(hidden_neurons, 
-                    return_sequences=True,
-                    stateful = stateful,
-                    name="RNN1", use_bias=True)(dnn1)
-    rnn = GRU(hidden_neurons, 
-                    return_sequences=False,
-                    stateful = stateful,
-                    name="RNN", use_bias=True)(rnn1)
-    # Output layer
-    dens = Dense(in_out_neurons,name="dense")(rnn)
-    # Define the model
-    model = Model(inputs=[inp],outputs=[dens])
-    # Compile the mdoel
-    model.compile(loss='mean_squared_error', optimizer='adam')  
-    # Return the model
+    # Compile the machine learning model using the mean squared error function as the loss 
+    # function and an Adams optimizer.
+    model.compile(loss="mean_squared_error", optimizer="adam")  
     return model
 
 # Check to make sure the data set is complete
@@ -221,8 +181,7 @@ rnn_input, rnn_training = format_data(y_trai
 
 # Create a recurrent neural network in Keras and produce a summary of the 
 # machine learning model
-# Change the method name to reflect which network you want to use
-model = dnn2_gru2(length_of_sequences = 2)
+model = rnn_2layers(length_of_sequences = 2)
 model.summary()
 
 # Start the timer.  Want to time training+testing
@@ -250,75 +209,8 @@ test_rnn(X_tot, y_tot, X_tot[0], X_tot[dim# Stop the timer and calculate the total time needed.
 end = timer()
 print('Time: ', end-start)
-
-
-# ### Training Recurrent Neural Networks in the Standard Way (i.e. learning the relationship between the X and Y data)
-# 
-# Finally, comparing the performace of a recurrent neural network using the standard data formatting to the performance of the network with time sequence data formatting shows the benefit of this type of data formatting with extrapolation.
-
-# Check to make sure the data set is complete
-assert len(X_tot) == len(y_tot)
-
-# This is the number of points that will be used in as the training data
-dim=12
-
-# Separate the training data from the whole data set
-X_train = X_tot[:dim]
-y_train = y_tot[:dim]
-
-# Reshape the data for Keras specifications
-X_train = X_train.reshape((dim, 1))
-y_train = y_train.reshape((dim, 1))
-
-
-# Create a recurrent neural network in Keras and produce a summary of the 
-# machine learning model
-# Set the sequence length to 1 for regular data formatting 
-model = rnn(length_of_sequences = 1)
-model.summary()
-
-# Start the timer.  Want to time training+testing
-start = timer()
-# Fit the model using the training data genenerated above using 150 training iterations and a 5%
-# validation split.  Setting verbose to True prints information about each training iteration.
-hist = model.fit(X_train, y_train, batch_size=None, epochs=150, 
-                 verbose=True,validation_split=0.05)
-
-
-# This section plots the training loss and the validation loss as a function of training iteration.
-# This is not required for analyzing the couple cluster data but can help determine if the network is
-# being overtrained.
-for label in ["loss","val_loss"]:
-    plt.plot(hist.history[label],label=label)
-
-plt.ylabel("loss")
-plt.xlabel("epoch")
-plt.title("The final validation loss: {}".format(hist.history["val_loss"][-1]))
-plt.legend()
-plt.show()
-
-# Use the trained neural network to predict the remaining data points
-X_pred = X_tot[dim:]
-X_pred = X_pred.reshape((len(X_pred), 1))
-y_model = model.predict(X_pred)
-y_pred = np.concatenate((y_tot[:dim], y_model.flatten()))
-
-# Plot the known data set and the predicted data set.  The red box represents the region that was used
-# for the training data.
-fig, ax = plt.subplots()
-ax.plot(X_tot, y_tot, label="true", linewidth=3)
-ax.plot(X_tot, y_pred, 'g-.',label="predicted", linewidth=4)
-ax.legend()
-# Created a red region to represent the points used in the training data.
-ax.axvspan(X_tot[0], X_tot[dim], alpha=0.25, color='red')
-plt.show()
-
-# Stop the timer and calculate the total time needed.
-end = timer()
-print('Time: ', end-start)
 
    
 
    
-
 
    
 
 
      
@@ -333,6 +225,8 @@ end = timer()
   
    • 8
      • 
   
    • 9
      • 
   
    • 10
      • 
+  
    • 11
      • 
+  
    • »
      • 
 
    
 
 
diff --git a/doc/pub/week43/html/._week43-bs010.html b/doc/pub/week43/html/._week43-bs010.html
index 1b874c4ac..e90043c62 100644
--- a/doc/pub/week43/html/._week43-bs010.html
+++ b/doc/pub/week43/html/._week43-bs010.html
@@ -42,60 +42,7 @@ Automatically generated HTML file from DocOnce source
 
 
 
 
-
-
-
-
-
-
-
     
 
 
    
@@ -151,39 +82,15 @@ MathJax.Hub.Config({
         Contents 
         
       
@@ -199,20 +106,221 @@ MathJax.Hub.Config({
 
 
 
-
    CNNs in more detail, building convolutional neural networks in Tensorflow and Keras 
    
+
    Other Types of Recurrent Neural Networks 
    
 
 
    
-As discussed above, CNNs are neural networks built from the assumption that the inputs
-to the network are 2D images. This is important because the number of features or pixels in images
-grows very fast with the image size, and an enormous number of weights and biases are needed in order to build an accurate network.
+Besides a simple recurrent neural network layer, there are two other
+commonly used types of recurrent neural network layers: Long Short
+Term Memory (LSTM) and Gated Recurrent Unit (GRU).  For a short
+introduction to these layers see https://medium.com/mindboard/lstm-vs-gru-experimental-comparison-955820c21e8b
+and https://medium.com/mindboard/lstm-vs-gru-experimental-comparison-955820c21e8b.
 
 
    
-As before, we still have our input, a hidden layer and an output. What's novel about convolutional networks
-are the convolutional and pooling layers stacked in pairs between the input and the hidden layer.
-In addition, the data is no longer represented as a 2D feature matrix, instead each input is a number of 2D
-matrices, typically 1 for each color dimension (Red, Green, Blue).
+The first network created below is similar to the previous network,
+but it replaces the SimpleRNN layers with LSTM layers.  The second
+network below has two hidden layers made up of GRUs, which are
+preceeded by two dense (feeddorward) neural network layers.  These
+dense layers "preprocess" the data before it reaches the recurrent
+layers.  This architecture has been shown to improve the performance
+of recurrent neural networks (see the link above and also
+https://arxiv.org/pdf/1807.02857.pdf.
 
 
    
+
+
+
    def lstm_2layers(length_of_sequences, batch_size = None, stateful = False):
+    """
+        Inputs:
+            length_of_sequences (an int): the number of y values in "x data".  This is determined
+                when the data is formatted
+            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.
+            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.
+        Returns:
+            model (a Keras model): The recurrent neural network that is built and compiled by this
+                method
+        Builds and compiles a recurrent neural network with two LSTM hidden layers and returns the model.
+    """
+    # Number of neurons on the input/output layer and the number of neurons in the hidden layer
+    in_out_neurons = 1
+    hidden_neurons = 250
+    # Input Layer
+    inp = Input(batch_shape=(batch_size, 
+                length_of_sequences, 
+                in_out_neurons)) 
+    # Hidden layers (in this case they are LSTM layers instead if SimpleRNN layers)
+    rnn= LSTM(hidden_neurons, 
+                    return_sequences=True,
+                    stateful = stateful,
+                    name="RNN", use_bias=True, activation='tanh')(inp)
+    rnn1 = LSTM(hidden_neurons, 
+                    return_sequences=False,
+                    stateful = stateful,
+                    name="RNN1", use_bias=True, activation='tanh')(rnn)
+    # Output layer
+    dens = Dense(in_out_neurons,name="dense")(rnn1)
+    # Define the midel
+    model = Model(inputs=[inp],outputs=[dens])
+    # Compile the model
+    model.compile(loss='mean_squared_error', optimizer='adam')  
+    # Return the model
+    return model
+
+def dnn2_gru2(length_of_sequences, batch_size = None, stateful = False):
+    """
+        Inputs:
+            length_of_sequences (an int): the number of y values in "x data".  This is determined
+                when the data is formatted
+            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.
+            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.
+        Returns:
+            model (a Keras model): The recurrent neural network that is built and compiled by this
+                method
+        Builds and compiles a recurrent neural network with four hidden layers (two dense followed by
+        two GRU layers) and returns the model.
+    """    
+    # Number of neurons on the input/output layers and hidden layers
+    in_out_neurons = 1
+    hidden_neurons = 250
+    # Input layer
+    inp = Input(batch_shape=(batch_size, 
+                length_of_sequences, 
+                in_out_neurons)) 
+    # Hidden Dense (feedforward) layers
+    dnn = Dense(hidden_neurons/2, activation='relu', name='dnn')(inp)
+    dnn1 = Dense(hidden_neurons/2, activation='relu', name='dnn1')(dnn)
+    # Hidden GRU layers
+    rnn1 = GRU(hidden_neurons, 
+                    return_sequences=True,
+                    stateful = stateful,
+                    name="RNN1", use_bias=True)(dnn1)
+    rnn = GRU(hidden_neurons, 
+                    return_sequences=False,
+                    stateful = stateful,
+                    name="RNN", use_bias=True)(rnn1)
+    # Output layer
+    dens = Dense(in_out_neurons,name="dense")(rnn)
+    # Define the model
+    model = Model(inputs=[inp],outputs=[dens])
+    # Compile the mdoel
+    model.compile(loss='mean_squared_error', optimizer='adam')  
+    # Return the model
+    return model
+
+# Check to make sure the data set is complete
+assert len(X_tot) == len(y_tot)
+
+# This is the number of points that will be used in as the training data
+dim=12
+
+# Separate the training data from the whole data set
+X_train = X_tot[:dim]
+y_train = y_tot[:dim]
+
+
+# Generate the training data for the RNN, using a sequence of 2
+rnn_input, rnn_training = format_data(y_train, 2)
+
+
+# Create a recurrent neural network in Keras and produce a summary of the 
+# machine learning model
+# Change the method name to reflect which network you want to use
+model = dnn2_gru2(length_of_sequences = 2)
+model.summary()
+
+# Start the timer.  Want to time training+testing
+start = timer()
+# Fit the model using the training data genenerated above using 150 training iterations and a 5%
+# validation split.  Setting verbose to True prints information about each training iteration.
+hist = model.fit(rnn_input, rnn_training, batch_size=None, epochs=150, 
+                 verbose=True,validation_split=0.05)
+
+
+# This section plots the training loss and the validation loss as a function of training iteration.
+# This is not required for analyzing the couple cluster data but can help determine if the network is
+# being overtrained.
+for label in ["loss","val_loss"]:
+    plt.plot(hist.history[label],label=label)
+
+plt.ylabel("loss")
+plt.xlabel("epoch")
+plt.title("The final validation loss: {}".format(hist.history["val_loss"][-1]))
+plt.legend()
+plt.show()
+
+# Use the trained neural network to predict more points of the data set
+test_rnn(X_tot, y_tot, X_tot[0], X_tot[dim-1])
+# Stop the timer and calculate the total time needed.
+end = timer()
+print('Time: ', end-start)
+
+
+# ### Training Recurrent Neural Networks in the Standard Way (i.e. learning the relationship between the X and Y data)
+# 
+# Finally, comparing the performace of a recurrent neural network using the standard data formatting to the performance of the network with time sequence data formatting shows the benefit of this type of data formatting with extrapolation.
+
+# Check to make sure the data set is complete
+assert len(X_tot) == len(y_tot)
+
+# This is the number of points that will be used in as the training data
+dim=12
+
+# Separate the training data from the whole data set
+X_train = X_tot[:dim]
+y_train = y_tot[:dim]
+
+# Reshape the data for Keras specifications
+X_train = X_train.reshape((dim, 1))
+y_train = y_train.reshape((dim, 1))
+
+
+# Create a recurrent neural network in Keras and produce a summary of the 
+# machine learning model
+# Set the sequence length to 1 for regular data formatting 
+model = rnn(length_of_sequences = 1)
+model.summary()
+
+# Start the timer.  Want to time training+testing
+start = timer()
+# Fit the model using the training data genenerated above using 150 training iterations and a 5%
+# validation split.  Setting verbose to True prints information about each training iteration.
+hist = model.fit(X_train, y_train, batch_size=None, epochs=150, 
+                 verbose=True,validation_split=0.05)
+
+
+# This section plots the training loss and the validation loss as a function of training iteration.
+# This is not required for analyzing the couple cluster data but can help determine if the network is
+# being overtrained.
+for label in ["loss","val_loss"]:
+    plt.plot(hist.history[label],label=label)
+
+plt.ylabel("loss")
+plt.xlabel("epoch")
+plt.title("The final validation loss: {}".format(hist.history["val_loss"][-1]))
+plt.legend()
+plt.show()
+
+# Use the trained neural network to predict the remaining data points
+X_pred = X_tot[dim:]
+X_pred = X_pred.reshape((len(X_pred), 1))
+y_model = model.predict(X_pred)
+y_pred = np.concatenate((y_tot[:dim], y_model.flatten()))
+
+# Plot the known data set and the predicted data set.  The red box represents the region that was used
+# for the training data.
+fig, ax = plt.subplots()
+ax.plot(X_tot, y_tot, label="true", linewidth=3)
+ax.plot(X_tot, y_pred, 'g-.',label="predicted", linewidth=4)
+ax.legend()
+# Created a red region to represent the points used in the training data.
+ax.axvspan(X_tot[0], X_tot[dim], alpha=0.25, color='red')
+plt.show()
+
+# Stop the timer and calculate the total time needed.
+end = timer()
+print('Time: ', end-start)
+
    
+
    
+
 
    
 
 
      
@@ -228,18 +336,6 @@ matrices, typically 1 for each color dimension (Red, Green, Blue).
   
    • 9
      • 
   
    • 10
      • 
   
    • 11
      • 
-  
    • 12
      • 
-  
    • 13
      • 
-  
    • 14
      • 
-  
    • 15
      • 
-  
    • 16
      • 
-  
    • 17
      • 
-  
    • 18
      • 
-  
    • 19
      • 
-  
    • 20
      • 
-  
    • ...
      • 
-  
    • 35
      • 
-  
    • »
      • 
 
    
 
 
diff --git a/doc/pub/week43/html/week43-bs.html b/doc/pub/week43/html/week43-bs.html
index 84c0a6a3d..60a56a623 100644
--- a/doc/pub/week43/html/week43-bs.html
+++ b/doc/pub/week43/html/week43-bs.html
@@ -42,6 +42,7 @@ Automatically generated HTML file from DocOnce source
 
         Contents 
         
       
@@ -146,6 +148,8 @@ end of tocinfo -->
   
  • 8
    • 
   
  • 9
    • 
   
  • 10
    • 
+  
  • ...
    • 
+  
  • 11
    • 
   
  • »
    • 
 
 
diff --git a/doc/pub/week43/html/week43-reveal.html b/doc/pub/week43/html/week43-reveal.html
index 5f08db866..3ce747595 100644
--- a/doc/pub/week43/html/week43-reveal.html
+++ b/doc/pub/week43/html/week43-reveal.html
@@ -170,6 +170,14 @@ td.padding {
 
 
 
+
    
+
    Summary on CNNs 
    
+
+
    
+Material to be added
+
    
+
+
 
    
 
    Recurrent neural networks: Overarching view 
    
 
diff --git a/doc/pub/week43/html/week43-solarized.html b/doc/pub/week43/html/week43-solarized.html
index d24fc990d..db1c0b406 100644
--- a/doc/pub/week43/html/week43-solarized.html
+++ b/doc/pub/week43/html/week43-solarized.html
@@ -62,6 +62,7 @@ div { text-align: justify; text-justify: inter-word; }
 
 
    
 
 
+
    
+









    
+
+
    Summary on CNNs 
    
+
+
    
+Material to be added
+
 
    
 









    
 
diff --git a/doc/pub/week43/html/week43.html b/doc/pub/week43/html/week43.html
index f6392f2f7..ef3e35a3f 100644
--- a/doc/pub/week43/html/week43.html
+++ b/doc/pub/week43/html/week43.html
@@ -67,6 +67,7 @@ div { text-align: justify; text-justify: inter-word; }
 
 
    
 
 
+
    
+









    
+
+
    Summary on CNNs 
    
+
+
    
+Material to be added
+
 
    
 









    
 
diff --git a/doc/pub/week43/ipynb/ipynb-week43-src.tar.gz b/doc/pub/week43/ipynb/ipynb-week43-src.tar.gz
index 9a802d72da1cace27e4df9ae0bc61a0a403d75af..193af45bc92713c3576fb2a9b58be50487f68d11 100644
GIT binary patch
literal 190
zcmV;v073sBiwFQjXmnu!1MSbz3W6{c24Js!it_}r>9p%0FS-aKdVz_@T;^umqNa}N1>v&$oUx4~ivAsJ&Z<|<34B=LNoP?`c|G)Y~J5(dN_V;TTi
zZlssqSgzeDZGA>*P`>NAT2+1cXI=%K`6rIGFtFVZwpJ3PvREk9zzwlsNhG>K7EmfQ
s;}dAS_Ch0YIRGz9VTF?X5_VdhG;d85{(2eD^E~fs4uHia9|^P13FfyKo_hc!88oZLCddlA^u6
zeSoeMH${Yen}0%vVdjvnH@hrycNZ*%5RxzkW2On8lC0+UB#t@6ET)_!G-WA}p`<(j
zvfN59opr(tt2EUal|}WgZ)hva4|C>I;F*8oSV;@peeWu*Kxv1$)-~J^Yepm4_9}-$
uqaDA%;I)$mL8u-?QAj7X5|^+w`ea07qwv?qc%J8ZUwZ&-6YCiO2mk;BG*%A)

diff --git a/doc/pub/week43/ipynb/week43.ipynb b/doc/pub/week43/ipynb/week43.ipynb
index 6fa70fe1c..a285a6b43 100644
--- a/doc/pub/week43/ipynb/week43.ipynb
+++ b/doc/pub/week43/ipynb/week43.ipynb
@@ -40,6 +40,9 @@
     "\n",
     "\n",
     "\n",
+    "## Summary on CNNs\n",
+    "\n",
+    "Material to be added\n",
     "\n",
     "\n",
     "## Recurrent neural networks: Overarching view\n",
diff --git a/doc/src/week43/week43.do.txt b/doc/src/week43/week43.do.txt
index 080e00e40..e8f437d40 100644
--- a/doc/src/week43/week43.do.txt
+++ b/doc/src/week43/week43.do.txt
@@ -20,6 +20,10 @@ DATE: today
 !eblock
 
 
+!split
+===== Summary on CNNs =====
+
+Material to be added
 
 
 !split