14-nnets-04-srn-statlearn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0ee17042-c37b-4dd4-8bcd-bcf65e5dd1ad",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "This tutorial is only for your fun / edification. No need to answer any lab questions you may find. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47e5df82-6ccf-43d6-ad89-15dce61b0977",
   "metadata": {},
   "source": [
    "# Neural networks, Part 4\n",
    "\n",
    "## *Human Statistical Learning: a publication-level example*\n",
    "---\n",
    "\n",
    "This notebook contains a nearly-complete implementation of a full training and analysis pipeline for a real domain of research in cognitive science: human **statistical learning**. \n",
    "\n",
    "I will give an overview of this domain in class. \n",
    "\n",
    "The basic idea is that if you expose a human (infant, child, or adult) to a stream of seemingly random syllables, but actually there is statistical structure to the syllables, they become sensitive to those statistics. \n",
    "\n",
    "In a classic study in *Science* in 1996, Jenny Saffran, Elissa Newport, and Dick Aslin presented 4-month-old infants with a 2-minute stream of syllables. They were auditory, but we can get a sense of how strange the input was by spelling it out (I've addded a few spaces to allow it to wrap, but there were no pauses in the input in the study):\n",
    "\n",
    "`tokibugikobagopilatipolutokibu gopilatipolutokibugikobagopila gikobatokibugopilatipolugikobatipolugikobatipolugopila tipolutokibugopilatipolutokibugopilatipolutokibugopilagikoba tipolutokibugopilagikobatipolugikobatipolugikobatipolu tokibugikobagopilatipolugikobatokibugopila`\n",
    "\n",
    "Although it sounds essentially random, it has 4 \"word-like\" patterns that repeat: `tokibu`, `gikoba`, `gopila`, `tipolu`. The words were in random order, with the constraint that a word could not repeat immediately. This mean that *transitional probabilities* were 1.0 within words (`ki` always follows `to`, and `bu` always follows `ki`) but 0.33 between words (`bu` was equally likely to be followed by `gi`, `go`, or `ti`). \n",
    "\n",
    "After 2 minutes of exposure, Saffran et al. tested babies' sensitivity to the statistical structure. They did this by sometimes playing one of the words from the mini-language over a speaker (e.g., the infant might hear `tokibu` repeated over and over), and sometimes playing a \"part-word\" made up of the last syllable of one word and the first 2 syllables of another (e.g., `lagiko`). They then measured how long the infants looked at the speaker while it was playing words vs. part-words. On average, infants looked significnatly longer at part-words (a so-called *novelty preference*). \n",
    "\n",
    "With adults, we can just play them a word and a part-word and ask 'which sounds more like what you were hearing earlier?'\n",
    "\n",
    "French et al. (2011) proposed a way to standardize across statistical learning studies with humans and computer models: a metric they called **proportion better**. Here you take your measure for words and subtract your measure for part-words (or vice versa when subjects show a novelty preference) and then divide by their sum. \n",
    "\n",
    "We can apply this with looking time by taking the difference in looking time over the sum: $(7.6-6.8) / (7.6+6.8) = 0.06$. \n",
    "\n",
    "With a neural network trained to process these kinds of items, we can look at how much error it makes predicting words vs. part-words. \n",
    "\n",
    "We can also use the amount of error to simulate trial-by-trial performance. We can take the error for a word, and compare it to the error for each part-word. Every time error is lower on the word, that's a case where the word is better. We do all the word-to-part-word comparisons and calculate **word choices**. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1291803a-25fd-4cc4-b38e-7a2999844d67",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "    \n",
    "### Note: 'statistical learning' means different things in different fields\n",
    "    \n",
    "There is an unfortunate interdisciplinary jargon conflict here. In computer science / engineering / artificial intelligence, 'statistical learning' is more or less a synonym for 'machine learning'. Psychologists appropriated this term to mean learning that appears to happen in an implicit way, based on statistical structure in some kind of information.\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95066c45-4dcb-4ba7-ac4a-e7a412400b04",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Simulating statistical learning\n",
    "\n",
    "So let's work towards trying to simulate performance in this task. We could try using a feedforward network or a simple recurrent network. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd6677c1-a00b-4aac-a185-bcf647620692",
   "metadata": {},
   "source": [
    "## Feedforward network\n",
    "\n",
    "Here's a schematic of a feedforward network (FFN). The dots within layers indicate that there could be arbitrarily many nodes within each layer. Note that connections only go 'forward', from the input towards the output. FFNs are typically trained just to do input-output mappings such as 'evaluate the truth value of these inputs with respect to the XOR function' or 'classify this image as a dog or a cat'. However, we could also try to train an FFN on sequences; for example, we could make the input-ouput mapping 'given the current input, try to output the next element in the sequence'. The FFN will be limited to learning the transitional probabilities from one element to another; it will not be able to learn to make predictions based on the previous input and the current input, for example. \n",
    "\n",
    "<div>\n",
    "<img src=\"figs/ff-tikz.png\" width=\"500\"/>\n",
    "</div>\n",
    "\n",
    "## Making it a Simple Recurrent Network (SRN)\n",
    "\n",
    "To make an SRN, we add **Context** nodes that provide additional inputs to the hidden layer at each time step. These special nodes get their states via special *copy-back* connections from the hidden nodes. These are 1-to-1 connections: $Hid_1$ connects only to $Context_1$, $Hid_2$ connects only to $Context_2$, etc. ($Hid_n$ connects only to $Context_n$). The weights on the copy-back links are always 1.0 so that we simply copy the activation values of the hidden layer at the previous time step. \n",
    "\n",
    "However, the context nodes are fully connected to the hidden layer -- every context node has a trainable, weighted connection to every hidden node. \n",
    "\n",
    "<div>\n",
    "<img src=\"figs/srn-tikz.png\" width=\"500\"/>\n",
    "</div>\n",
    "\n",
    "This gives the network the capability of developing senstivity to sequential information. It is not limited to just one step back in time, though, because it can adjust the context-to-hidden weights (as well as input-to-hidden weights) such that it can preserve information going back possibly many steps, in a context-sensitive way (here 'context' is meant in its generic sense, not just with respect to the context nodes). \n",
    "\n",
    "The SRN will be able to learn not just simple transitional probabilities between adjacent elements in sequences, but also dependencies based on several time steps. For example, if A can be followed by B, C, or D, but then the next element after that is always E (e.g., ABE, ACE, ADE), the network will learn that contingency readily (even if B, C and E can be followed by other items in different contexts, e.g., JBF, KBH, LCM, etc.). \n",
    "\n",
    "Jeff Elman originally developed SRNs in the late 1980s, with the first publications in 1990 and 1991. He trained them to do *next-item prediction*: given the current element in a sequence, predict the next one. This could be 'predict the next phoneme given the current phoneme' or 'predict the next word given the current word'. This is the basis for contemporary 'large language models' (like Chat-GPT) -- they also do next-word prediction.\n",
    "\n",
    "Why are they called *simple* recurrent networks? This is in contrast to (fully) recurrent networks, that hold store many, many previous states (in some cases many thousands). There are special algorithms for training them (*backpropagation through time*, or BPTT), but they are very memory intensive and difficult to analyze and understand. The SRN is simple in the sense that it just holds onto 1 time step, and copies it essentially into the input. This allows the weighted connections (all the solid lines in the diagram above) to be trained using regular backpropagation of error. It's a truly simple innovation, but it has proved to be incredibly powerful. \n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "### A note: Assessing learning\n",
    "    \n",
    "In the statistical learning task described above, it is impossible to perform perfectly and make no errors. An optimal, ideal system would make no errors *within* words, where the second and third syllables are perfectly predictable, but could not perfectly predict what comes next. This is because after the final syllable of a word, the next syllable will be the first syllable of one of the other three words, selected at random. Thus, an optimal, ideal system would make no error within words, but the best it could do at word boundaries would be to activate the first syllables of the other three words equally.\n",
    "    \n",
    "</div>\n",
    "\n",
    "\n",
    "### Some details about the SRN architecture\n",
    "\n",
    "We will build an SRN below. There are a few details to highlight.\n",
    "\n",
    "- We will train a network by presenting it with 'symbols' that represent different syllables. For example, if we have 12 syllables (like Saffran et al. did, with their 4 three-syllable words), we would have 12 input nodes. Each would stand for a different syllable. We would also then have 12 outputs -- again, one for each syllable. The network's task will be to try to activate the output node for the next syllable in response to the input node for the current syllable. \n",
    "\n",
    "- We will use $tanh$ (hyperbolic tangent) activation function in the hidden layer, like we did for the XOR network we trained in the previous notebook. \n",
    "\n",
    "- We will use the $sigmoid$ activation function for the output layer, again like we did for XOR. \n",
    "\n",
    "- We will include a bias node that has a connection to every hidden node. If you explore the code, you will find that the network will still learn just fine if you eliminate it; however, it tends to learn faster with it.\n",
    "\n",
    "- We will use an extremely similar weight-update algorithm as in the single-output XOR network, even though we will have 12 outputs. The next section explains this. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35f9dd68-38d0-4b82-9396-aab754923058",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "### *Skip this section if you are not interested in this level of detail.*\n",
    "    \n",
    "### Understanding error signal in the context of sigmoid activation and *Cross-Entropy Loss*\n",
    "\n",
    "In a neural network with sigmoid activation and cross-entropy loss, the calculation of the error signal is quite straightforward and elegant due to the properties of these functions.\n",
    "\n",
    "1. **Sigmoid Activation Function**: \n",
    "   The sigmoid function, defined as $\\sigma(x) = \\frac{1}{1 + e^{-x}}$, outputs a value between 0 and 1. This output is typically interpreted as the probability of the positive class in binary classification.\n",
    "\n",
    "2. **Cross-Entropy Loss**: \n",
    "   For binary classification, cross-entropy loss is defined as:\n",
    "   $$ L = -[y \\log(p) + (1-y) \\log(1-p)] $$\n",
    "   where $y$ is the true label (0 or 1), and $p$ is the predicted probability (output of the sigmoid function).\n",
    "\n",
    "3. **Derivative of Cross-Entropy Loss**:\n",
    "   The derivative of the cross-entropy loss with respect to the input of the sigmoid function (which is the raw output of the network before applying the sigmoid) simplifies beautifully when combined with the derivative of the sigmoid function itself. The derivative of the sigmoid function $\\sigma(x)$ is $\\sigma(x) (1 - \\sigma(x))$. Applying the chain rule, the derivative of the loss with respect to the raw output ends up being the simple difference between the predicted probability and the actual target:\n",
    "   $$ p - y $$\n",
    "\n",
    "This simplification, where the error signal is just the difference between the predicted probability and the actual target, is one of the key reasons why the combination of sigmoid activation and cross-entropy loss is popular, especially for binary classification tasks. It leads to a more stable and efficient training process compared to using mean squared error with sigmoid activation, as the gradient is more responsive even when the predicted probability is close to the actual label.\n",
    "\n",
    "Thus, when the error signal is calculated as `output_vec - target_vec` in the backpropagation algorithm, it effectively uses the derivative of the cross-entropy loss with respect to the network's output. This approach provides the correct gradient for weight updates in a network using sigmoid outputs and cross-entropy loss.\n",
    "\n",
    "**However, we are not doing simple binary classification -- we have 12 possible outputs. How does this still work?**\n",
    "\n",
    "### Cross-Entropy Loss for *Multi-Class* Classification\n",
    "\n",
    "In a neural network designed for multi-class classification with 12 categories, using sigmoid activation for each category and cross-entropy loss, the error signal computation is slightly more complex than in binary classification but still maintains a straightforward approach.\n",
    "\n",
    "#### Sigmoid Activation Function:\n",
    "In multi-class classification with 12 categories, each output neuron corresponds to one category. The sigmoid function is applied to each neuron's output, giving a probability-like value between 0 and 1. However, it's important to note that these values don't necessarily sum up to 1 across all categories (unlike softmax activation which is often used in multi-class classification).\n",
    "\n",
    "#### Cross-Entropy Loss for Multi-Class Classification:\n",
    "The cross-entropy loss in multi-class classification is a generalization of the binary case. It's actually simpler. It is defined as:\n",
    "\n",
    "$$ L = -\\sum_{c=1}^{n} y_c \\log(p_c) $$\n",
    "\n",
    "where $ n $ is the number of classes (12 in our case), $ y_c $ is 1 if the true category is $ c $ and 0 otherwise (one-hot encoded), and $ p_c $ is the predicted probability for category $ c $. This loss function calculates a separate loss for each category and then sums them up.\n",
    "\n",
    "However, \n",
    "\n",
    "#### Derivative of Cross-Entropy Loss:\n",
    "Just as in the binary case, the error signal in the multi-class scenario can be calculated elegantly. The derivative of the cross-entropy loss with respect to the input of the sigmoid function for each category is the difference between the predicted probability and the actual target for that category:\n",
    "\n",
    "$$ p_c - y_c $$\n",
    "\n",
    "for each category $ c $.\n",
    "\n",
    "Therefore, in a 12-category classification task, the error signal for each category (neuron) in the output layer is the difference between the neuron's activation (interpreted as the predicted probability for that category) and the corresponding value in the one-hot encoded target vector. This error signal is then used in backpropagation to update the weights.\n",
    "\n",
    "However, we can also keep the code we used previously; the binary case actually works fine so long as we sum the loss over each output node. This works because the targets (syllables) are one-hot encoded, representing multiple classes (different syllables), and the network predicts the probability of each class (syllable) independently. Let's clarify this:\n",
    "\n",
    "#### Multi-Class Setting:\n",
    "Each syllable in our lexicon is a separate class or category. The network essentially predicts the probability of each syllable being the next one in the sequence. The output layer has as many nodes as there are unique syllables, with each node corresponding to a particular syllable.\n",
    "\n",
    "#### Sigmoid Activation:\n",
    "The sigmoid function is applied to the input of each output node, providing a probability-like score for each syllable. Unlike softmax, which normalizes outputs across all classes to sum up to 1, the sigmoid function treats each output independently. This means the network predicts the likelihood of each syllable independently, not as a mutually exclusive set.\n",
    "\n",
    "#### Cross-Entropy Loss for Multi-Class (One-Hot Targets):\n",
    "The cross-entropy loss is calculated for each neuron (syllable) independently and then summed up. This is appropriate for our case where each target is a one-hot encoded vector, representing the correct syllable. The loss function penalizes the network for the difference between its predicted probability and the actual target (1 for the correct syllable, 0 for others). \n",
    "\n",
    "#### Error Signal:\n",
    "For each node, the error signal (used in backpropagation) is the difference between the predicted probability (output of the sigmoid function) and the actual target in the one-hot encoded vector. This guides the network to increase the probability for the correct syllable and decrease it for the others.\n",
    "\n",
    "Thus, even though the setup looks similar to binary classification, it's actually a multi-class classification where each class (syllable) is treated independently. The network learns to predict the likelihood of each syllable in the lexicon, and the cross-entropy loss function is an effective choice for this kind of problem.\n",
    "\n",
    "    \n",
    "**Summary**. This process efficiently directs the network to adjust its predictions towards the actual distribution of the categories, provided by the one-hot encoded target vectors. The cross-entropy loss function in conjunction with sigmoid activation remains an effective choice for multi-class classification due to its ability to penalize incorrect predictions robustly and guide the network towards accurate category probabilities.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a249ced5-37b4-4472-bd49-52c37170f544",
   "metadata": {},
   "source": [
    "## Coding up the SRN\n",
    "\n",
    "Note that the code below uses a fairly simple approach, just using the basic `numpy` package for numeric processing in Python. There are more powerful approaches, such as using PyTorch to make use of Facebook AI's Torch toolkit, or Keras along with Torch, TensorFlow, or JAX. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d84f0ba3-1158-43ff-951f-078e7b5283ef",
   "metadata": {},
   "source": [
    "### Import needed libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7e98dfe3-1716-491c-a653-ac24562e0fdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "import time \n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da2063f8-ab3d-4df4-9962-c5f4312a0020",
   "metadata": {},
   "source": [
    "## Plotting routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3f8f9d88-690a-49e9-aeb6-ab205977dcf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_training_progress(loss_history, word_choices_history, prop_better_history, \\\n",
    "                           combined_input_target_output_matrix, combined_hidden_context_matrix, \\\n",
    "                           W_input_hidden, W_context_hidden, W_hidden_output, epoch, loss_lexicon_history=None):\n",
    "\n",
    "    clear_output(wait=True)\n",
    "    fig = plt.figure(figsize=(15, 6))\n",
    "\n",
    "    # Create a GridSpec for layout\n",
    "    # gs = fig.add_gridspec(5, 3, width_ratios=[2, 1, 0.1], height_ratios=[3, 2, 5, 5, 5])\n",
    "    gs = fig.add_gridspec(5, 4, width_ratios=[4, 4, 2, 0.1], height_ratios=[3, 2, 5, 5, 5])\n",
    "\n",
    "    # Plot loss\n",
    "    ax_loss = fig.add_subplot(gs[:, 0])\n",
    "    ax_loss.plot(range(1, len(loss_history) + 1), loss_history, label='Training')\n",
    "    if loss_lexicon_history is not None:\n",
    "        # Plot red points for loss_lexicon (test loss)\n",
    "        epochs_with_test = [i for i, loss in enumerate(loss_lexicon_history) if not np.isnan(loss)]\n",
    "        test_losses = [loss for loss in loss_lexicon_history if not np.isnan(loss)]\n",
    "        ax_loss.scatter(epochs_with_test, test_losses, color='violet', s=25, label='Testing', zorder=5)\n",
    "    # Adding grey dashed lines at y=0\n",
    "    ax_loss.axhline(y=0, color='lightgrey', linestyle='--')\n",
    "    ax_loss.set_xlabel('Epoch')\n",
    "    ax_loss.set_ylabel('Cross-Entropy Loss')\n",
    "    ax_loss.set_title(f'Loss vs Epochs, EPOCH {epoch}')\n",
    "    ax_loss.legend()\n",
    "    \n",
    "    # New subplot for proportion_better and word_choices\n",
    "    ax_tests = fig.add_subplot(gs[:, 1])\n",
    "    if prop_better_history is not None:\n",
    "        #ax_tests.plot(range(1, len(prop_better_history) + 1), prop_better_history, 'r.', markersize=10, label='Proportion Better')\n",
    "        # Plotting both points and a connecting line\n",
    "        # ax_tests.plot(range(1, len(prop_better_history) + 1), prop_better_history, 'r.-', label='Proportion Better', markersize=5)  # Connecting line with points\n",
    "        epochs = range(1, len(prop_better_history) + 1)\n",
    "        ax_tests.plot(epochs, prop_better_history, 'r.', label='Proportion Better', markersize=5)\n",
    "        # Plotting line separately, ignoring NaNs\n",
    "        non_nan_indices = ~np.isnan(prop_better_history)\n",
    "        ax_tests.plot(np.array(epochs)[non_nan_indices], np.array(prop_better_history)[non_nan_indices], 'r-')  # Connecting line for non-NaN segments\n",
    "\n",
    "    if word_choices_history is not None:\n",
    "        epochs = range(1, len(word_choices_history) + 1)\n",
    "        ax_tests.plot(range(1, len(word_choices_history) + 1), word_choices_history, 'b.', markersize=5, label='Word Choices')\n",
    "        # Plotting line separately, ignoring NaNs\n",
    "        non_nan_indices = ~np.isnan(word_choices_history)\n",
    "        ax_tests.plot(np.array(epochs)[non_nan_indices], np.array(word_choices_history)[non_nan_indices], 'b-')  # Connecting line for non-NaN segments\n",
    "    # Adding grey dashed lines at y=0 and y=0.5\n",
    "    ax_tests.axhline(y=0, color='mistyrose', linestyle='--')\n",
    "    ax_tests.axhline(y=0.5, color='skyblue', linestyle='--')\n",
    "    ax_tests.set_xlabel('Epoch')\n",
    "    ax_tests.set_ylabel('Test Metrics')\n",
    "    ax_tests.set_title('Test Performance Metrics')\n",
    "    ax_tests.legend()\n",
    "\n",
    "    # Plotting the heatmap for Input, Target, and Output\n",
    "    ax_input_target_output_heatmap = fig.add_subplot(gs[0, 2])\n",
    "    input_target_output_heatmap = ax_input_target_output_heatmap.imshow(combined_input_target_output_matrix, cmap='hot', interpolation='nearest', aspect='auto')\n",
    "    ax_input_target_output_heatmap.set_title('Input, Target & Output Vectors')\n",
    "    ax_input_target_output_heatmap.set_yticks([0, 1, 2])\n",
    "    ax_input_target_output_heatmap.set_yticklabels(['Input', 'Target', 'Output'])\n",
    "    ax_input_target_output_heatmap_cbar = fig.add_subplot(gs[0, 3])\n",
    "    plt.colorbar(input_target_output_heatmap, cax=ax_input_target_output_heatmap_cbar)\n",
    "\n",
    "    # Plot combined hidden-context heatmap\n",
    "    ax_hidden_context_heatmap = fig.add_subplot(gs[1, 2])\n",
    "    hidden_context_heatmap = ax_hidden_context_heatmap.imshow(combined_hidden_context_matrix, cmap='hot', interpolation='nearest', aspect='auto')\n",
    "    ax_hidden_context_heatmap.set_title('Hidden & Context States')\n",
    "    ax_hidden_context_heatmap.set_yticks([0, 1])\n",
    "    ax_hidden_context_heatmap.set_yticklabels(['Hidden', 'Context'])\n",
    "    ax_hidden_context_heatmap_cbar = fig.add_subplot(gs[1, 3])\n",
    "    plt.colorbar(hidden_context_heatmap, cax=ax_hidden_context_heatmap_cbar)\n",
    "\n",
    "    # Plot input-to-hidden weight matrix heatmap\n",
    "    ax_input_hidden_heatmap = fig.add_subplot(gs[2, 2])\n",
    "    input_hidden_heatmap = ax_input_hidden_heatmap.imshow(W_input_hidden, cmap='hot', interpolation='nearest', aspect='auto')\n",
    "    ax_input_hidden_heatmap.set_title('Input-to-Hidden Weights')\n",
    "    ax_input_hidden_heatmap_cbar = fig.add_subplot(gs[2, 3])\n",
    "    plt.colorbar(input_hidden_heatmap, cax=ax_input_hidden_heatmap_cbar)\n",
    "\n",
    "    # Plot context-to-hidden weight matrix heatmap\n",
    "    ax_context_hidden_heatmap = fig.add_subplot(gs[3, 2])\n",
    "    context_hidden_heatmap = ax_context_hidden_heatmap.imshow(W_context_hidden, cmap='hot', interpolation='nearest', aspect='auto')\n",
    "    ax_context_hidden_heatmap.set_title('Context-to-Hidden Weights')\n",
    "    ax_context_hidden_heatmap_cbar = fig.add_subplot(gs[3, 3])\n",
    "    plt.colorbar(context_hidden_heatmap, cax=ax_context_hidden_heatmap_cbar)\n",
    "\n",
    "    # Plot hidden-to-output weight matrix heatmap\n",
    "    ax_hidden_output_heatmap = fig.add_subplot(gs[4, 2])\n",
    "    hidden_output_heatmap = ax_hidden_output_heatmap.imshow(W_hidden_output, cmap='hot', interpolation='nearest', aspect='auto')\n",
    "    ax_hidden_output_heatmap.set_title('Hidden-to-Output Weights')\n",
    "    ax_hidden_output_heatmap_cbar = fig.add_subplot(gs[4, 3])\n",
    "    plt.colorbar(hidden_output_heatmap, cax=ax_hidden_output_heatmap_cbar)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d4690f2-a283-4b29-a920-815b17b9b96d",
   "metadata": {},
   "source": [
    "## Network functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "57c060e7-2c47-4bf9-9ee3-f7e84328e64a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "\n",
    "# Function to process the lexicon and map syllables to indices\n",
    "def process_lexicon(lexicon):\n",
    "    unique_syllables = sorted(set(''.join(lexicon)))\n",
    "    syllable_to_index = {syllable: i for i, syllable in enumerate(unique_syllables)}\n",
    "    return unique_syllables, syllable_to_index\n",
    "\n",
    "def initialize_network(lexicon, nhidden=None, method='normal', wmean=0, wsd=0.25):\n",
    "    _, syllable_to_index = process_lexicon(lexicon)\n",
    "    n_syllables = len(syllable_to_index)\n",
    "    \n",
    "    # if nhidden == None, set nhidden to by n_syllables\n",
    "    nhidden = nhidden or n_syllables\n",
    "\n",
    "    if method == \"uniform\":\n",
    "        W_input_hidden = np.random.randn(n_syllables, nhidden) * 0.01\n",
    "        W_context_hidden = np.random.randn(nhidden, nhidden) * 0.01  # New weights\n",
    "        W_hidden_output = np.random.randn(nhidden, n_syllables) * 0.01\n",
    "        hidden_state = np.zeros(nhidden)\n",
    "        W_bias_hidden = np.random.randn(nhidden) * 0.01  # Bias weights\n",
    "    else:\n",
    "        W_input_hidden = np.random.normal(wmean, wsd, (n_syllables, nhidden))\n",
    "        W_context_hidden = np.random.normal(wmean, wsd, (nhidden, nhidden))\n",
    "        W_hidden_output = np.random.normal(wmean, wsd, (nhidden, n_syllables))\n",
    "        W_bias_hidden = np.random.normal(wmean, wsd, nhidden)\n",
    "        hidden_state = np.zeros(nhidden)\n",
    "        \n",
    "\n",
    "    return W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, hidden_state\n",
    "\n",
    "def save_weights(W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, filename_prefix):\n",
    "    np.save(f'{filename_prefix}_input_hidden.npy', W_input_hidden)\n",
    "    np.save(f'{filename_prefix}_bias_hidden.npy', W_bias_hidden)\n",
    "    np.save(f'{filename_prefix}_context_hidden.npy', W_context_hidden)\n",
    "    np.save(f'{filename_prefix}_hidden_output.npy', W_hidden_output)\n",
    "    print(\"Weights saved successfully.\")\n",
    "    # Example of saving weights\n",
    "    # save_weights(W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, 'network_weights')\n",
    "\n",
    "\n",
    "def load_weights(filename_prefix):\n",
    "    W_input_hidden = np.load(f'{filename_prefix}_input_hidden.npy')\n",
    "    W_bias_hidden = np.load(f'{filename_prefix}_bias_hidden.npy')\n",
    "    W_context_hidden = np.load(f'{filename_prefix}_context_hidden.npy')\n",
    "    W_hidden_output = np.load(f'{filename_prefix}_hidden_output.npy')\n",
    "    print(\"Weights loaded successfully.\")\n",
    "    return W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output\n",
    "\n",
    "    \n",
    "#def binary_cross_entropy_loss(y_true, y_pred):\n",
    "def cross_entropy_loss(y_true, y_pred):\n",
    "    return -np.sum(y_true * np.log(y_pred + 1e-15) + (1 - y_true) * np.log(1 - y_pred + 1e-15))\n",
    "\n",
    "def multi_cross_entropy_loss(y_true, y_pred):\n",
    "    # Ensure small value is added to y_pred to avoid log(0)\n",
    "    epsilon = 1e-15\n",
    "    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)\n",
    "\n",
    "    # Calculate cross-entropy loss\n",
    "    loss = -np.sum(y_true * np.log(y_pred))\n",
    "    return loss\n",
    "\n",
    "# Function to generate the sequence of words for an epoch\n",
    "def generate_epoch_sequence(lexicon, frequency, lexbatch=None, no_repeat=True):\n",
    "    epoch_sequence = []\n",
    "    if lexbatch:\n",
    "        for _ in range(lexbatch):\n",
    "            batch = lexicon * frequency\n",
    "            random.shuffle(batch)\n",
    "            if no_repeat:\n",
    "                # Ensure no repeated word at the boundary\n",
    "                while batch[0] == epoch_sequence[-1]:\n",
    "                    random.shuffle(batch)\n",
    "            epoch_sequence.extend(batch)\n",
    "    else:\n",
    "        epoch_sequence = lexicon * frequency\n",
    "        random.shuffle(epoch_sequence)\n",
    "        if no_repeat:\n",
    "            # Ensure no repeated word at the start\n",
    "            while len(epoch_sequence) > 1 and epoch_sequence[0] == epoch_sequence[-1]:\n",
    "                random.shuffle(epoch_sequence)\n",
    "\n",
    "    # Convert the sequence of words into a sequence of letters\n",
    "    letter_sequence = ''.join(epoch_sequence)\n",
    "    return letter_sequence\n",
    "\n",
    "# Function to encode words to input and target vectors\n",
    "def encode_word(word, syllable_to_index):\n",
    "    vec = np.zeros(len(syllable_to_index))\n",
    "    vec[syllable_to_index[word]] = 1\n",
    "    # vec[syllable_to_index[word[-1]]] = 1  # Encoding the last syllable as target\n",
    "    return vec\n",
    "\n",
    "# Function to calculate loss on a given sequence of words\n",
    "def calculate_loss_on_sequence(sequence, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, \\\n",
    "                               syllable_to_index, hidden_state):\n",
    "    total_loss = 0\n",
    "    num_syllables = len(sequence) - 1  # Subtract 1 because the last syllable has no following syllable as a target\n",
    "\n",
    "    for i in range(len(sequence) - 1):\n",
    "        input_vec = encode_word(sequence[i], syllable_to_index)\n",
    "        target_vec = encode_word(sequence[i + 1], syllable_to_index)\n",
    "        _, output_vec = forward_pass(input_vec, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, hidden_state)\n",
    "        this_loss = cross_entropy_loss(target_vec, output_vec)\n",
    "        total_loss += this_loss\n",
    "        # print(f'\\n#{sequence}\\n\\tINPUT {input_vec}\\n\\tTARGET {target_vec}\\n\\tOUTPUT {output_vec}\\n\\tthisLOSS {this_loss}, totLOSS {total_loss}')\n",
    "    \n",
    "    # time.sleep(4)\n",
    "    average_loss_per_syllable = total_loss / num_syllables\n",
    "    return average_loss_per_syllable\n",
    "    # return total_loss\n",
    "\n",
    "# Function to calculate error for individual word for all but last item, since target is not defined\n",
    "def calculate_word_error(word, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, \\\n",
    "                         syllable_to_index, hidden_state):\n",
    "    total_error = 0\n",
    "    for i in range(len(word) - 1):\n",
    "        input_vec = encode_word(word[i], syllable_to_index)\n",
    "        target_vec = encode_word(word[i + 1], syllable_to_index)\n",
    "        _, output_vec = forward_pass(input_vec, \\\n",
    "                                     W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, hidden_state)\n",
    "        total_error += cross_entropy_loss(target_vec, output_vec)\n",
    "    return total_error\n",
    "\n",
    "# Function to calculate word choices\n",
    "def calculate_word_choices(lex_errors, comp_errors):\n",
    "    word_better_count = 0\n",
    "    total_comparisons = 0\n",
    "    for lex_error, comp_error in zip(lex_errors, comp_errors):\n",
    "        total_comparisons += 1\n",
    "        if lex_error < comp_error:\n",
    "            word_better_count += 1\n",
    "    return word_better_count / total_comparisons if total_comparisons > 0 else 0\n",
    "\n",
    "\n",
    "# Function to calculate proportion better\n",
    "def prop_better_and_word_choices(lexicon, comparison_items, \\\n",
    "                                W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, \\\n",
    "                                syllable_to_index):\n",
    "    # Calculate errors for each word in lexicon and comparison items\n",
    "    lex_errors = [calculate_word_error(word, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, \\\n",
    "                                       syllable_to_index, np.zeros_like(hidden_state)) for word in lexicon]\n",
    "    comp_errors = [calculate_word_error(word, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, \\\n",
    "                                        syllable_to_index, np.zeros_like(hidden_state)) for word in comparison_items]\n",
    "\n",
    "    # Word choices calculation\n",
    "    wchoices = calculate_word_choices(lex_errors, comp_errors)\n",
    "    \n",
    "    # Mean errors\n",
    "    lexicon_mean_error = sum(lex_errors) / len(lex_errors)\n",
    "    comparison_mean_error = sum(comp_errors) / len(comp_errors)\n",
    "\n",
    "    # Proportion better calculation\n",
    "    pbetter = (comparison_mean_error - lexicon_mean_error) / (comparison_mean_error + lexicon_mean_error)\n",
    "    \n",
    "    return pbetter, wchoices\n",
    "\n",
    "# The forward pass of the network with context-to-hidden connections\n",
    "def forward_pass(input_vec, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, hidden_state):\n",
    "    # new_hidden_state = np.tanh(np.dot(input_vec, W_input_hidden) + np.dot(hidden_state, W_context_hidden))\n",
    "    new_hidden_state = np.tanh(np.dot(input_vec, W_input_hidden) + W_bias_hidden + np.dot(hidden_state, W_context_hidden))\n",
    "    # new_hidden_state = np.tanh(np.dot(input_vec, W_input_hidden) + W_bias_hidden) #+ np.dot(hidden_state, W_context_hidden))\n",
    "    output_vec = sigmoid(np.dot(new_hidden_state, W_hidden_output))  # Applying sigmoid activation\n",
    "    return new_hidden_state, output_vec\n",
    "\n",
    "\n",
    "# The training function\n",
    "def train_network(lexicon, epochs, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, \n",
    "                  hidden_state, learning_rate=0.01, print_interval=10, test_interval=100,\n",
    "                  colorbar_width=0.02, colorbar_pad=0.02, nhidden=None, testlexicon=None):\n",
    "\n",
    "    if testlexicon is None:\n",
    "        testlexicon = lexicon\n",
    "    \n",
    "    unique_syllables, syllable_to_index = process_lexicon(lexicon)\n",
    "    \n",
    "    if nhidden is None:\n",
    "        nhidden = len(unique_syllables)\n",
    "\n",
    "    # initialize history vectors\n",
    "    input_history = []  # To store input vectors for visualization\n",
    "    output_history = []  # To store output vectors for visualization\n",
    "    hidden_state_history = []  # To store hidden state vectors for visualization\n",
    "    loss_history = []\n",
    "    loss_lexicon_history = [np.nan] * epochs  # Initialize with NaNs\n",
    "    prop_better_history = [np.nan] * epochs  # Initialize with NaNs\n",
    "    word_choices_history = [np.nan] * epochs  # Initialize with NaNs\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        letter_sequence = generate_epoch_sequence(lexicon, 1)\n",
    "        # epoch_sequence = generate_epoch_sequence(lexicon, 1)  # Frequency set to 1 for simplicity\n",
    "        total_loss = 0\n",
    "\n",
    "        # Generate input and target sequences\n",
    "        input_sequence = letter_sequence[:-1]  # All except the last element\n",
    "        target_sequence = letter_sequence[1:]  # All except the first element\n",
    "        \n",
    "        combined_input_target_matrix = np.zeros((2, len(syllable_to_index)))\n",
    "        combined_input_target_output_matrix = np.zeros((3, len(syllable_to_index)))  # Adding a row for output\n",
    "\n",
    "        combined_hidden_context_matrix = np.zeros((2, nhidden))\n",
    "        # break\n",
    "        \n",
    "        # Backpropagation (updated for Cross-Entropy Loss)\n",
    "        for input_letter, target_letter in zip(input_sequence, target_sequence):\n",
    "            input_vec = encode_word(input_letter, syllable_to_index)\n",
    "            target_vec = encode_word(target_letter, syllable_to_index)\n",
    "        # for input_word, target_word in zip(input_sequence, target_sequence):\n",
    "        #     input_vec = encode_word(input_word, syllable_to_index)\n",
    "        #     target_vec = encode_word(target_word, syllable_to_index)\n",
    "\n",
    "            new_hidden_state, output_vec = forward_pass(input_vec, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, hidden_state)\n",
    "\n",
    "            #nhidden = len(hidden_state)\n",
    "\n",
    "            \n",
    "            # Calculate loss\n",
    "            loss = cross_entropy_loss(target_vec, output_vec)\n",
    "            loss = cross_entropy_loss(target_vec, output_vec)\n",
    "            total_loss += loss\n",
    "\n",
    "            # Error signal for output layer\n",
    "            error_signal = output_vec - target_vec\n",
    "\n",
    "            # Gradient for W_hidden_output\n",
    "            dW_hidden_output = np.outer(new_hidden_state, error_signal)\n",
    "\n",
    "            # Error signal for hidden layer (propagating back through the network)\n",
    "            hidden_error_signal = np.dot(W_hidden_output, error_signal) * (1 - new_hidden_state ** 2)\n",
    "\n",
    "            # Gradient for W_context_hidden\n",
    "            dW_context_hidden = np.outer(hidden_state, hidden_error_signal)\n",
    "\n",
    "            # Gradient for W_input_hidden\n",
    "            dW_input_hidden = np.outer(input_vec, hidden_error_signal)\n",
    "\n",
    "            # Gradient for W_bias_hidden\n",
    "            dW_bias_hidden = hidden_error_signal\n",
    "\n",
    "            # Update weights\n",
    "            W_input_hidden -= learning_rate * dW_input_hidden\n",
    "            W_context_hidden -= learning_rate * dW_context_hidden\n",
    "            W_hidden_output -= learning_rate * dW_hidden_output\n",
    "            W_bias_hidden -= learning_rate * dW_bias_hidden\n",
    "\n",
    "\n",
    "            context_state = hidden_state\n",
    "            hidden_state = new_hidden_state\n",
    "            hidden_state_history.append(hidden_state.copy())  # Store the hidden state\n",
    "            \n",
    "            combined_input_target_output_matrix[0, :] = input_vec\n",
    "            combined_input_target_output_matrix[1, :] = target_vec\n",
    "            combined_input_target_output_matrix[2, :] = output_vec  # Add output vector to the matrix\n",
    "\n",
    "            combined_hidden_context_matrix[0, :] = hidden_state\n",
    "            combined_hidden_context_matrix[1, :] = context_state\n",
    "\n",
    "\n",
    "        # At the end of each epoch, append the average loss to loss_history\n",
    "        average_loss = total_loss / len(input_sequence)\n",
    "        loss_history.append(average_loss)\n",
    "\n",
    "\n",
    "        # # print(f\"Epoch {epoch+1}, Total loss: {total_loss}\"\n",
    "        # loss_history.append(total_loss / len(input_sequence))\n",
    "\n",
    "        input_history.append(input_vec)\n",
    "        output_history.append(output_vec)\n",
    "\n",
    "        if epoch % test_interval == 0:\n",
    "            # Test (1): Loss on the Lexicon\n",
    "            loss_lexicon = calculate_loss_on_sequence(''.join(testlexicon), W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, syllable_to_index, hidden_state)\n",
    "            loss_lexicon_history[epoch] = loss_lexicon\n",
    "            shifted_lexicon = testlexicon[1:] + testlexicon[:1]  # Shift the lexicon order\n",
    "            loss_shifted = calculate_loss_on_sequence(''.join(shifted_lexicon), W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, syllable_to_index, hidden_state)\n",
    "\n",
    "            # Test (2): Proportion Better & word choices\n",
    "            proportion_better, word_choices = prop_better_and_word_choices(lexicon, comparison_items, \\\n",
    "                                                                           W_input_hidden, W_bias_hidden, \\\n",
    "                                                                           W_context_hidden, W_hidden_output, \\\n",
    "                                                                           syllable_to_index)\n",
    "            prop_better_history[epoch] = proportion_better\n",
    "            word_choices_history[epoch] = word_choices\n",
    "\n",
    "            # print(f\"\\nEpoch {epoch}: Loss Lexicon {loss_lexicon:.4f}, Loss Shifted {loss_shifted:.4f}, Proportion Better {proportion_better:.4f}, Word Choices {word_choices:.4f}\")\n",
    "            print(f\"\\nEpoch {epoch}: Test loss {loss_lexicon:.4f}, Proportion Better {proportion_better:.4f}, Word Choices {word_choices:.4f}\")\n",
    "            # if epoch > 4950:\n",
    "            #     time.sleep(1)\n",
    "\n",
    "        if epoch % print_interval == 0 or epoch == epochs - 1:\n",
    "            plot_training_progress(loss_history, word_choices_history, prop_better_history, combined_input_target_output_matrix, combined_hidden_context_matrix, \n",
    "                                   W_input_hidden, W_context_hidden, W_hidden_output, epoch, loss_lexicon_history)\n",
    "            print(f'\\rInput: {input_sequence}\\tTarget: {target_sequence}        ',end=\"\")\n",
    "            \n",
    "\n",
    "        hidden_state_history = []  # Reset hidden state history for next interval\n",
    "        print(f\"\\nEpoch {epoch}: Test loss {loss_lexicon:.4f}, Proportion Better {proportion_better:.4f}, Word Choices {word_choices:.4f}\")\n",
    "        # print(f\"\\nEpoch {epoch}: Loss Lexicon {loss_lexicon:.4f}, Loss Shifted {loss_shifted:.4f}, Proportion Better {proportion_better:.4f}, Word Choices {word_choices:.4f}\")\n",
    "        \n",
    "    return W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, hidden_state"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08190569-7e15-4d50-a927-fbd9c66388f9",
   "metadata": {},
   "source": [
    "## Using the code\n",
    "\n",
    "The cell below uses the functions we've defined above to train a network. You'll get plots of loss (error), 'test metrics' (proportion better and word choices), heat maps of weights. There are also heat maps showing inputs (what syllable is current input), targets (what is the desired target), and outputs (activations over output nodes). You'll see that the output node corresponding to the target gets lighter (moves towards white) as training progresses, indicating it can actually predict the upcoming targets fairly well. \n",
    "\n",
    "Keep in mind that the network could potentially get perfect at predicting syllables within words (transitional probabilities are 1.0 within words) but not between words (where transitional probabilities are 0.333 since there are 3 possible next syllables when we get to the end of one word). \n",
    "\n",
    "Run this cell to train the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d2de329b-98f0-4c2e-879a-095ac55d9acd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x600 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: GHIDEFJKLAB\tTarget: HIDEFJKLABC        \n",
      "Epoch 1999: Test loss 1.6095, Proportion Better 0.1011, Word Choices 0.7500\n"
     ]
    }
   ],
   "source": [
    "# Example usage\n",
    "# Here are 4 'words' akin to the items used by Saffran et al. (1996)\n",
    "lexicon = ['ABC', 'DEF', 'GHI', 'JKL']\n",
    "# testlexicon = ['ABC', 'DEF'] # Saffran et al only used the first 2 words\n",
    "testlexicon=None\n",
    "\n",
    "# Here are 4 'part-words' made up of the last syllable of 1 word and the first 2 syllables of another\n",
    "comparison_items = ['CDE', 'FGH', 'IJK', 'LAB']  # Example\n",
    "# comparison_items = ['IJK', 'AGH']  # Modeled directly after the items used by Saffran et al\n",
    "# if nhid is set to None, the actual number will be the same as number of unique syllables in lexicon,\n",
    "# which is the approach of French et al. 2011\n",
    "#nhid = 2\n",
    "nhid = 6\n",
    "#nhid = 20\n",
    "# nhid = 12\n",
    "# nhid = None \n",
    "W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, hidden_state = initialize_network(lexicon, \\\n",
    "                                                                                                    nhidden=nhid)\n",
    "nepochs = 2000\n",
    "W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, hidden_state = \\\n",
    "    train_network(lexicon, nepochs, W_input_hidden, W_bias_hidden, W_context_hidden, W_hidden_output, \\\n",
    "                  hidden_state, print_interval=10, nhidden=nhid, learning_rate=0.005, test_interval=10, \\\n",
    "                  testlexicon=testlexicon)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cb4e984-1b35-4dbf-a7b5-5cc5542ec2fc",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## <font color='red'>Ideas for exploration</font>\n",
    "\n",
    "1. Try changing the number of hidden nodes. Comment out the line `nhid = None` (when `nhid` is set to `None`, the number of hidden units is set to the number of input units) and uncomment one of the other ones. Try setting `nhid` to 2. Increase `nepochs` to see if the network can learn. (Hint: it's unlikely to get good at this task with 2 hidden nodes.) What's the smallest number of hidden nodes you can specify and have the system learn in reasonable time? What happens if you specify a lot of nodes (30 or 300)? Note that it may also be helpful to increase or decrease the learning rate. \n",
    "\n",
    "2. Try eliminating the bias nodes (simplest way: set them to zero initially and comment out the steps that update the bias-to-hidden weights). Does this change things? Does it change how few hidden nodes you can use? \n",
    "\n",
    "3. Remove the context nodes (simplest way: intialize the weights to zero and comment out the steps that update context-to-hidden weights). This will make this a feedforward network without memory. Can it still learn this task? \n",
    "\n",
    "---\n",
    "\n",
    "## How we could move something like this to publication\n",
    "\n",
    "As we'll discuss in class, SRNs were largely dismissed as a good model for human statistical learning due to some famous apparent failures reported ~15 years ago. This means a useful paper would be one that would do a few things. \n",
    "\n",
    "1. Train many instances of each model and average results to make sure we are not focused on flukes. In a paper I'm working on, I repeat each simulation 100 times. \n",
    "\n",
    "2. Apply SRNs to classic cases like Saffran et al. (1996) but also the cases where people reported they fail. I've done this, and with some corrections to poor procedures in previous work, SRNs work great. \n",
    "\n",
    "3. Try to identify which statistical learning tasks really require long-distance dependencies (i.e., more than predicting the next syllable directly from the current one). I found that the early, classic studies (Saffran et al., 1996; Aslin et al., 1998) can be learned by feedforward networks that can only learn adjacent syllable transitional probabilities, but many others require the memory provided by an SRN. My challenge now is figuring out what the actual statistical information acquired by the SRN is in those cases. If this is a challenge you would be interested in learning more about or even working on, let me know!  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5462dc3e-5783-4e7e-ba20-4fb23fe6fe92",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## <font color='red'>Ambitious challenge questions</font>\n",
    "\n",
    "1. What computational capacities are needed to simulate the Saffran et al. paradigm? Could we simulate this with a feedforward network? Try copying the SRN code to a new notebook and remove the context nodes and connections. This would make it a feedforward network. How could you train it to simulate the task? What if the feedforward network can learn this task -- what would the implications be?\n",
    "\n",
    "2. Aslin, Saffran, & Newport (1998) observed that there was a 'confound' in the Saffran et al. (1996) paradigm: words occurred more frequently than part words, so perhaps infants were sensitive to the 'surface frequency' of syllable sequences rather than transitional probabilities. To control for this, they made 2 of the words 'high frequency' by having them occur twice as often as the other two words. Then they were able to select high-frequency partwords (the end of one high-frequency word and the first 2 syllables of another) that were matched in surface frequency with the low-frequency words. Infants preferred low-frequency words to frequency-matched partwords, suggesting they were attuning to transitional probabilities. Would you predict that an SRN would show lower error on low-frequency words than frequency-matched partwords? Can you implement this and test the SRN? \n",
    "\n",
    "3. French et al. (2011) created a clever 'box language' where TPs were always 0.5. The language is depicted in this figure from their paper. a1 is always followed by either a2 or a3. a2 is always followed by b1 or c1, etc. So the 'forward' TPs are always 0.5. But the 'backward' TPs are high (1.0) within words (a2 is **always** preceded by a1) but low between words (a1 can be preceded by b2, b3, c2 or c3, so the backward TP is 0.25). This also means that words have higher frequency than partwords (every time a2 occurs, a1-a2 has occurred, while half the time a2-b1 will occur and half the time a2-c1 will occur, so words occur twice as often as partwords). Infants preferred partwords (e.g., a2-b1) to words (a1-a2) (that is, they showed a *novelty preference* as did infants in Saffran et al., 1996). Would you predict an SRN would show lower error on words than partwords? Could you implement this and test the SRN? (Suggestion: rather than a1, a2, etc., perhaps have an A box, M box, and X box; possible words could be AB, AC, MN, MO, XY, XZ. This would allow you to use the same code we have been using, which assumes each syllable is represented by one letter.)\n",
    "\n",
    "<div>\n",
    "<img src=\"figs/french-etal-2011-fig6-box-language.png\" width=\"500\"/>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "654049da-235c-44dd-b573-50b94a0dd315",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}