ProgressiveRatio

ProgressiveRatio

Overview

The progressive ratio schedule was first described by Hodos (1961) as a method to quantify the motivational strength of reinforcers. Unlike fixed ratio schedules, where the number of responses per reward is constant, the PR schedule increases the response requirement after each successive reward. For example, in a PR1 schedule, the animal must make 1 poke for the first pellet, 2 pokes for the second, 3 for the third, and so on. The point at which the animal ceases responding, known as the breakpoint, is considered a robust measure of motivation and willingness to expend effort.

In FED-based closed economy applications, the PR program can run continuously in the home cage. To allow animals to resume responding after disengagement, a reset rule is included: if no poke is made within 30 minutes, the ratio requirement resets back to 1:1. This ensures animals are not permanently locked out at very high ratio demands, while still allowing long-term measurement of motivational processes.

Theory

PR performance reflects both the reinforcing efficacy of the reward and the subject’s willingness to tolerate escalating cost. Dopaminergic signaling in striatal circuits is central to sustaining responding under rising effort demands, while prefrontal circuits contribute to persistence and cost–benefit evaluation. Drugs or manipulations that enhance dopamine signaling increase breakpoints, whereas antagonists, lesions, or metabolic challenges typically lower them. Because the task forces animals to reveal the maximum effort they will invest for a reward, it is widely used as a sensitive assay of motivation.

Considerations

• Step size: The progression (e.g., PR1 linear increase, PR2, or exponential schedules) should be chosen to balance sensitivity and feasibility.

• Reset rule (FED-specific): If no poke is made for 30 minutes, the ratio resets to FR1 to enable re-engagement.

• Reinforcer type: Different food types or palatability levels can shift breakpoints, making PR useful for comparing reward value.

• Animal welfare: Escalating effort can suppress intake; body weight and health must be monitored closely.

• Interpretation: Breakpoints index motivation, but can also be constrained by motor capacity or satiety.

Key Features

• Progressive reinforcement schedule: each successive reward requires more responses (e.g., 1 → 2 → 3 → … pokes per pellet).
• Breakpoint: the final ratio completed before responding ceases.
• FED-specific reset: if no poke is made within 30 minutes, the requirement resets to FR1.
• Measures motivational drive, effort tolerance, and reinforcer value.
• Sensitive to pharmacological, genetic, and environmental manipulations.
• Supports long-term measurement in naturalistic closed economy conditions.

Code Highlights

// ---- FED3 Progressive Ratio Task ----
#include <FED3.h>

int poke_num = 0;                         // Number of pokes since last reward
int pokes_required = 1;                   // Pokes needed for next pellet (progresses)
String sketch = "ProgRat";                // Task identifier for log files
FED3 fed3(sketch);                        // Initialize FED3 object

void setup() {
  fed3.begin();                           // Initialize FED3 hardware & SD logging
}

void loop() {
  fed3.run();                             // Keep FED3 running and checking inputs

  // --- Left poke behavior (active nose poke) ---
  if (fed3.Left) {
    fed3.logLeftPoke();                   // Log the poke to SD card
    poke_num++;                           // Increment poke count for current ratio

    if (poke_num == pokes_required) {     // Check if requirement met
      fed3.ConditionedStimulus();         // Cue: lights + tone
      fed3.Feed();                        // Deliver pellet

      // Update next ratio requirement (Richardson & Roberts, 1996 formula)
      pokes_required = round((5 * exp((fed3.PelletCount + 1) * 0.2)) - 5);
      fed3.FR = pokes_required;           // Store ratio value for log consistency

      poke_num = 0;                       // Reset poke counter for next reward
      fed3.Left = false;                  // Clear poke flag
    } 
    else {
      fed3.Click();                       // Feedback click if requirement not yet met
    }
  }

  // --- Right poke (inactive control) ---
  if (fed3.Right) {
    fed3.logRightPoke();                  // Log right pokes separately
  }
}
       // Dispenses a pellet

Usage

1. Upload this sketch to your FED3 using Arduino IDE.
2. Observe behavior and log file output.
3. Adjust timeout duration or ratio progression rules if different contingencies are desired.

Logging

• Logs pellet events, poke activity, timeouts, and more depending on sketch.

Sample data

• Sample PR1 Data

Full Code

/*
  Feeding experimentation device 3 (FED3)
  Progressive Ratio Script.
  The number of pellets required increments by the forumla in Richardson and Roberts (1996) https://www.ncbi.nlm.nih.gov/pubmed/8794935

  alexxai@wustl.edu and kbarclay@wustl.edu
  December, 2020

  This project is released under the terms of the Creative Commons - Attribution - ShareAlike 3.0 license:
  human readable: https://creativecommons.org/licenses/by-sa/3.0/
  legal wording: https://creativecommons.org/licenses/by-sa/3.0/legalcode
  Copyright (c) 2020 Lex Kravitz
*/

#include <FED3.h>                                      //Include the FED3 library 
int poke_num = 0;                                      // this variable is the number of pokes since last pellet
int pokes_required = 1;                                //increase the number of pokes required each time a pellet is received using an exponential equation
String sketch = "ProgRat";                            //Unique identifier text for each sketch
FED3 fed3 (sketch);                                    //Start the FED3 object

void setup() {
  fed3.begin();                                        //Setup the FED3 hardware
}

void loop() {
  fed3.run();                                          //Call fed.run at least once per loop
  if (fed3.Left) {                                     //If left poke is triggered and pellet is not in the well
    fed3.logLeftPoke();                                //Log left poke
    poke_num++;                                        //store this new poke number as current poke number.
    if (poke_num == pokes_required) {                  //check to see if the mouse has acheived the correct number of pokes in order to receive the pellet
      fed3.ConditionedStimulus();                      //Deliver conditioned stimulus (tone and lights)
      fed3.Feed();                                     //Deliver pellet
      
      //increment the number of pokes required according to the progressive ratio:
      pokes_required = round((5 * exp((fed3.PelletCount + 1) * 0.2)) - 5);  //this is an exponential ratio, change this line to edit ratio formula
      
      fed3.FR = pokes_required;
      poke_num = 0;                                    //reset the number of pokes back to 0, for the next trial
      fed3.Left = false;
    }
    else {
      fed3.Click();                                    //If not enough pokes, just do a Click
    }
  }

  if (fed3.Right) {                                    //If right poke is triggered and pellet is not in the well
    fed3.logRightPoke();
  }
}

Reference

Hodos, W. (1961). Progressive ratio as a measure of reward strength. Science, 134(3483), 943–944.