Declarative Memory

githubjimmyd edited this page Mar 6, 2019 · 20 revisions

In the psychological theory that ACT-R uses, humans have many memory types.

Some memories are of fact-like beliefs, such as that whales are mammals, or that Moskow is the capital of Russia. These kinds of memories are fact-like (propositional), and we can often retrieve them and be consciously aware of them. Other kinds of memory might be associations between concepts (associative memories), or memories of how to do things (procedural memory).

In ACT-R, the declarative memory is distinct from the procedural memory (which is the set of productions.)

Each declarative memory is called a "chunk."

The ACT-R agent requests a memory from the long-term declarative memory store, and retrieved memories go into the declarative memory buffer. We can think of this buffer's size as being able to hold about 2 to 6 chunks (often referred to as "four plus or minus two.")

For example, an agent might want to recall the capital of Russia. They might submit a request to declarative memory that looks like this:

Country: Russia Capital: ?

If the agent knows that Moskow is the capital of Russia, then the full "chunk" will be put in declarative memory.

Country: Russia Capital: Moskow

A request production puts a copy of the chunk in the declarative memory buffer, and another production will be activated in order to use it for anything.

Activation

Your ability to retrieve a declarative memory is determined by its current activation level ("activation.") If the activation of a particular chunk is below the threshold, it cannot be retrieved. Higher activations are more quickly retrieved. The threshold can move up and down, depending on the agent's focus.

According to ACT-R theory, the brain updates the activation of all memories all the time. But this is computationally expensive, so the implemented versions of ACT-R simplify this so computers can actually run it.

Activation can be turned on or off.

Noise

The brain is a wet, biological system. The current activation level of a chunk is subject to some noise. In Python ACT-R, noise is just about always set to 0.3.

Decay

Activation goes down over time. This is known as decay. It follows a classic "forgetting curve;" a negative exponential. It will continue to do this until it asymptotes to the base level activation (see below).

Image from https://blog.wranx.com/ebbinghaus-forgetting-curve

In the real world, decay happens, but often declarative memories in the declarative memory buffer are pushed out by other retrieved memories. Some think of this decay as a stand-in for interference from other memories, but rather than modelling these distractions, we just approximate it with decay.

Increasing Activation

When you use a chunk, its activation level goes up.

Base Activation

No matter what you happen to be thinking about today, certain memories are more easily retrieved than others in general. A chunk's activation can decay until it reaches its base level. When we refer to "activation," we mean the current activation, and if we mean the base activation, we will call it as such.

To raise the base level activation, the agent tries to add a new chunk to declarative memory, but that chunk already exists. So the agent either adds a new chunk to the declarative memory, or increases the base activation of the same chunk that already exists there.

Spreading Activation

Memories activate other memories they are related to (the "targets.") This is called "spreading activation." We'll talk about it happening from a source memory to target memories. When a source activates a target, the source does not lose activation.

How does Python ACT-R determine targets? It ignores slot names, and uses values. If a chunk contains the same symbol that is in the source, then that chunk is a target. This is Python ACT-R's implementation of semantic priming.

Only retrieved chunks are sources. Targets do not become sources unless they are retrieved.

There are also associative targets in Python ACT-R. That is, two things experienced simultaneously are connected by association, even if there's no relation between them (like has-a, or isa-a).

How much is spread? It's a function of a few things, including the strength of association between the two chunks.

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Skip to content

Declarative Memory

githubjimmyd edited this page Mar 6, 2019 · 20 revisions

In the psychological theory that ACT-R uses, humans have many memory types.

Some memories are of fact-like beliefs, such as that whales are mammals, or that Moskow is the capital of Russia. These kinds of memories are fact-like (propositional), and we can often retrieve them and be consciously aware of them. Other kinds of memory might be associations between concepts (associative memories), or memories of how to do things (procedural memory).

In ACT-R, the declarative memory is distinct from the procedural memory (which is the set of productions.)

Each declarative memory is called a "chunk."

The ACT-R agent requests a memory from the long-term declarative memory store, and retrieved memories go into the declarative memory buffer. We can think of this buffer's size as being able to hold about 2 to 6 chunks (often referred to as "four plus or minus two.")

For example, an agent might want to recall the capital of Russia. They might submit a request to declarative memory that looks like this:

Country: Russia Capital: ?

If the agent knows that Moskow is the capital of Russia, then the full "chunk" will be put in declarative memory.

Country: Russia Capital: Moskow

A request production puts a copy of the chunk in the declarative memory buffer, and another production will be activated in order to use it for anything.

Activation

Your ability to retrieve a declarative memory is determined by its current activation level ("activation.") If the activation of a particular chunk is below the threshold, it cannot be retrieved. Higher activations are more quickly retrieved. The threshold can move up and down, depending on the agent's focus.

According to ACT-R theory, the brain updates the activation of all memories all the time. But this is computationally expensive, so the implemented versions of ACT-R simplify this so computers can actually run it.

Activation can be turned on or off.

Noise

The brain is a wet, biological system. The current activation level of a chunk is subject to some noise. In Python ACT-R, noise is just about always set to 0.3.

Decay

Activation goes down over time. This is known as decay. It follows a classic "forgetting curve;" a negative exponential. It will continue to do this until it asymptotes to the base level activation (see below).

Image from https://blog.wranx.com/ebbinghaus-forgetting-curve

In the real world, decay happens, but often declarative memories in the declarative memory buffer are pushed out by other retrieved memories. Some think of this decay as a stand-in for interference from other memories, but rather than modelling these distractions, we just approximate it with decay.

Increasing Activation

When you use a chunk, its activation level goes up.

Base Activation

No matter what you happen to be thinking about today, certain memories are more easily retrieved than others in general. A chunk's activation can decay until it reaches its base level. When we refer to "activation," we mean the current activation, and if we mean the base activation, we will call it as such.

To raise the base level activation, the agent tries to add a new chunk to declarative memory, but that chunk already exists. So the agent either adds a new chunk to the declarative memory, or increases the base activation of the same chunk that already exists there.

Spreading Activation

Memories activate other memories they are related to (the "targets.") This is called "spreading activation." We'll talk about it happening from a source memory to target memories. When a source activates a target, the source does not lose activation.

How does Python ACT-R determine targets? It ignores slot names, and uses values. If a chunk contains the same symbol that is in the source, then that chunk is a target. This is Python ACT-R's implementation of semantic priming.

Only retrieved chunks are sources. Targets do not become sources unless they are retrieved.

There are also associative targets in Python ACT-R. That is, two things experienced simultaneously are connected by association, even if there's no relation between them (like has-a, or isa-a).

How much is spread? It's a function of a few things, including the strength of association between the two chunks.

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix"); } } catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + '
Skip to content

Declarative Memory

githubjimmyd edited this page Mar 6, 2019 · 20 revisions

In the psychological theory that ACT-R uses, humans have many memory types.

Some memories are of fact-like beliefs, such as that whales are mammals, or that Moskow is the capital of Russia. These kinds of memories are fact-like (propositional), and we can often retrieve them and be consciously aware of them. Other kinds of memory might be associations between concepts (associative memories), or memories of how to do things (procedural memory).

In ACT-R, the declarative memory is distinct from the procedural memory (which is the set of productions.)

Each declarative memory is called a "chunk."

The ACT-R agent requests a memory from the long-term declarative memory store, and retrieved memories go into the declarative memory buffer. We can think of this buffer's size as being able to hold about 2 to 6 chunks (often referred to as "four plus or minus two.")

For example, an agent might want to recall the capital of Russia. They might submit a request to declarative memory that looks like this:

Country: Russia Capital: ?

If the agent knows that Moskow is the capital of Russia, then the full "chunk" will be put in declarative memory.

Country: Russia Capital: Moskow

A request production puts a copy of the chunk in the declarative memory buffer, and another production will be activated in order to use it for anything.

Activation

Your ability to retrieve a declarative memory is determined by its current activation level ("activation.") If the activation of a particular chunk is below the threshold, it cannot be retrieved. Higher activations are more quickly retrieved. The threshold can move up and down, depending on the agent's focus.

According to ACT-R theory, the brain updates the activation of all memories all the time. But this is computationally expensive, so the implemented versions of ACT-R simplify this so computers can actually run it.

Activation can be turned on or off.

Noise

The brain is a wet, biological system. The current activation level of a chunk is subject to some noise. In Python ACT-R, noise is just about always set to 0.3.

Decay

Activation goes down over time. This is known as decay. It follows a classic "forgetting curve;" a negative exponential. It will continue to do this until it asymptotes to the base level activation (see below).

Image from https://blog.wranx.com/ebbinghaus-forgetting-curve

In the real world, decay happens, but often declarative memories in the declarative memory buffer are pushed out by other retrieved memories. Some think of this decay as a stand-in for interference from other memories, but rather than modelling these distractions, we just approximate it with decay.

Increasing Activation

When you use a chunk, its activation level goes up.

Base Activation

No matter what you happen to be thinking about today, certain memories are more easily retrieved than others in general. A chunk's activation can decay until it reaches its base level. When we refer to "activation," we mean the current activation, and if we mean the base activation, we will call it as such.

To raise the base level activation, the agent tries to add a new chunk to declarative memory, but that chunk already exists. So the agent either adds a new chunk to the declarative memory, or increases the base activation of the same chunk that already exists there.

Spreading Activation

Memories activate other memories they are related to (the "targets.") This is called "spreading activation." We'll talk about it happening from a source memory to target memories. When a source activates a target, the source does not lose activation.

How does Python ACT-R determine targets? It ignores slot names, and uses values. If a chunk contains the same symbol that is in the source, then that chunk is a target. This is Python ACT-R's implementation of semantic priming.

Only retrieved chunks are sources. Targets do not become sources unless they are retrieved.

There are also associative targets in Python ACT-R. That is, two things experienced simultaneously are connected by association, even if there's no relation between them (like has-a, or isa-a).

How much is spread? It's a function of a few things, including the strength of association between the two chunks.

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms"); } } catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + '
Skip to content

Declarative Memory

githubjimmyd edited this page Mar 6, 2019 · 20 revisions

In the psychological theory that ACT-R uses, humans have many memory types.

Some memories are of fact-like beliefs, such as that whales are mammals, or that Moskow is the capital of Russia. These kinds of memories are fact-like (propositional), and we can often retrieve them and be consciously aware of them. Other kinds of memory might be associations between concepts (associative memories), or memories of how to do things (procedural memory).

In ACT-R, the declarative memory is distinct from the procedural memory (which is the set of productions.)

Each declarative memory is called a "chunk."

The ACT-R agent requests a memory from the long-term declarative memory store, and retrieved memories go into the declarative memory buffer. We can think of this buffer's size as being able to hold about 2 to 6 chunks (often referred to as "four plus or minus two.")

For example, an agent might want to recall the capital of Russia. They might submit a request to declarative memory that looks like this:

Country: Russia Capital: ?

If the agent knows that Moskow is the capital of Russia, then the full "chunk" will be put in declarative memory.

Country: Russia Capital: Moskow

A request production puts a copy of the chunk in the declarative memory buffer, and another production will be activated in order to use it for anything.

Activation

Your ability to retrieve a declarative memory is determined by its current activation level ("activation.") If the activation of a particular chunk is below the threshold, it cannot be retrieved. Higher activations are more quickly retrieved. The threshold can move up and down, depending on the agent's focus.

According to ACT-R theory, the brain updates the activation of all memories all the time. But this is computationally expensive, so the implemented versions of ACT-R simplify this so computers can actually run it.

Activation can be turned on or off.

Noise

The brain is a wet, biological system. The current activation level of a chunk is subject to some noise. In Python ACT-R, noise is just about always set to 0.3.

Decay

Activation goes down over time. This is known as decay. It follows a classic "forgetting curve;" a negative exponential. It will continue to do this until it asymptotes to the base level activation (see below).

Image from https://blog.wranx.com/ebbinghaus-forgetting-curve

In the real world, decay happens, but often declarative memories in the declarative memory buffer are pushed out by other retrieved memories. Some think of this decay as a stand-in for interference from other memories, but rather than modelling these distractions, we just approximate it with decay.

Increasing Activation

When you use a chunk, its activation level goes up.

Base Activation

No matter what you happen to be thinking about today, certain memories are more easily retrieved than others in general. A chunk's activation can decay until it reaches its base level. When we refer to "activation," we mean the current activation, and if we mean the base activation, we will call it as such.

To raise the base level activation, the agent tries to add a new chunk to declarative memory, but that chunk already exists. So the agent either adds a new chunk to the declarative memory, or increases the base activation of the same chunk that already exists there.

Spreading Activation

Memories activate other memories they are related to (the "targets.") This is called "spreading activation." We'll talk about it happening from a source memory to target memories. When a source activates a target, the source does not lose activation.

How does Python ACT-R determine targets? It ignores slot names, and uses values. If a chunk contains the same symbol that is in the source, then that chunk is a target. This is Python ACT-R's implementation of semantic priming.

Only retrieved chunks are sources. Targets do not become sources unless they are retrieved.

There are also associative targets in Python ACT-R. That is, two things experienced simultaneously are connected by association, even if there's no relation between them (like has-a, or isa-a).

How much is spread? It's a function of a few things, including the strength of association between the two chunks.

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links"); } } catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); } })(); (function(){ try { var __m = "youtube.com"; var __re = new RegExp('^' + "youtube\\.com" + '
Skip to content

Declarative Memory

githubjimmyd edited this page Mar 6, 2019 · 20 revisions

In the psychological theory that ACT-R uses, humans have many memory types.

Some memories are of fact-like beliefs, such as that whales are mammals, or that Moskow is the capital of Russia. These kinds of memories are fact-like (propositional), and we can often retrieve them and be consciously aware of them. Other kinds of memory might be associations between concepts (associative memories), or memories of how to do things (procedural memory).

In ACT-R, the declarative memory is distinct from the procedural memory (which is the set of productions.)

Each declarative memory is called a "chunk."

The ACT-R agent requests a memory from the long-term declarative memory store, and retrieved memories go into the declarative memory buffer. We can think of this buffer's size as being able to hold about 2 to 6 chunks (often referred to as "four plus or minus two.")

For example, an agent might want to recall the capital of Russia. They might submit a request to declarative memory that looks like this:

Country: Russia Capital: ?

If the agent knows that Moskow is the capital of Russia, then the full "chunk" will be put in declarative memory.

Country: Russia Capital: Moskow

A request production puts a copy of the chunk in the declarative memory buffer, and another production will be activated in order to use it for anything.

Activation

Your ability to retrieve a declarative memory is determined by its current activation level ("activation.") If the activation of a particular chunk is below the threshold, it cannot be retrieved. Higher activations are more quickly retrieved. The threshold can move up and down, depending on the agent's focus.

According to ACT-R theory, the brain updates the activation of all memories all the time. But this is computationally expensive, so the implemented versions of ACT-R simplify this so computers can actually run it.

Activation can be turned on or off.

Noise

The brain is a wet, biological system. The current activation level of a chunk is subject to some noise. In Python ACT-R, noise is just about always set to 0.3.

Decay

Activation goes down over time. This is known as decay. It follows a classic "forgetting curve;" a negative exponential. It will continue to do this until it asymptotes to the base level activation (see below).

Image from https://blog.wranx.com/ebbinghaus-forgetting-curve

In the real world, decay happens, but often declarative memories in the declarative memory buffer are pushed out by other retrieved memories. Some think of this decay as a stand-in for interference from other memories, but rather than modelling these distractions, we just approximate it with decay.

Increasing Activation

When you use a chunk, its activation level goes up.

Base Activation

No matter what you happen to be thinking about today, certain memories are more easily retrieved than others in general. A chunk's activation can decay until it reaches its base level. When we refer to "activation," we mean the current activation, and if we mean the base activation, we will call it as such.

To raise the base level activation, the agent tries to add a new chunk to declarative memory, but that chunk already exists. So the agent either adds a new chunk to the declarative memory, or increases the base activation of the same chunk that already exists there.

Spreading Activation

Memories activate other memories they are related to (the "targets.") This is called "spreading activation." We'll talk about it happening from a source memory to target memories. When a source activates a target, the source does not lose activation.

How does Python ACT-R determine targets? It ignores slot names, and uses values. If a chunk contains the same symbol that is in the source, then that chunk is a target. This is Python ACT-R's implementation of semantic priming.

Only retrieved chunks are sources. Targets do not become sources unless they are retrieved.

There are also associative targets in Python ACT-R. That is, two things experienced simultaneously are connected by association, even if there's no relation between them (like has-a, or isa-a).

How much is spread? It's a function of a few things, including the strength of association between the two chunks.

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default"); } } catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + '
Skip to content

Declarative Memory

githubjimmyd edited this page Mar 6, 2019 · 20 revisions

In the psychological theory that ACT-R uses, humans have many memory types.

Some memories are of fact-like beliefs, such as that whales are mammals, or that Moskow is the capital of Russia. These kinds of memories are fact-like (propositional), and we can often retrieve them and be consciously aware of them. Other kinds of memory might be associations between concepts (associative memories), or memories of how to do things (procedural memory).

In ACT-R, the declarative memory is distinct from the procedural memory (which is the set of productions.)

Each declarative memory is called a "chunk."

The ACT-R agent requests a memory from the long-term declarative memory store, and retrieved memories go into the declarative memory buffer. We can think of this buffer's size as being able to hold about 2 to 6 chunks (often referred to as "four plus or minus two.")

For example, an agent might want to recall the capital of Russia. They might submit a request to declarative memory that looks like this:

Country: Russia Capital: ?

If the agent knows that Moskow is the capital of Russia, then the full "chunk" will be put in declarative memory.

Country: Russia Capital: Moskow

A request production puts a copy of the chunk in the declarative memory buffer, and another production will be activated in order to use it for anything.

Activation

Your ability to retrieve a declarative memory is determined by its current activation level ("activation.") If the activation of a particular chunk is below the threshold, it cannot be retrieved. Higher activations are more quickly retrieved. The threshold can move up and down, depending on the agent's focus.

According to ACT-R theory, the brain updates the activation of all memories all the time. But this is computationally expensive, so the implemented versions of ACT-R simplify this so computers can actually run it.

Activation can be turned on or off.

Noise

The brain is a wet, biological system. The current activation level of a chunk is subject to some noise. In Python ACT-R, noise is just about always set to 0.3.

Decay

Activation goes down over time. This is known as decay. It follows a classic "forgetting curve;" a negative exponential. It will continue to do this until it asymptotes to the base level activation (see below).

Image from https://blog.wranx.com/ebbinghaus-forgetting-curve

In the real world, decay happens, but often declarative memories in the declarative memory buffer are pushed out by other retrieved memories. Some think of this decay as a stand-in for interference from other memories, but rather than modelling these distractions, we just approximate it with decay.

Increasing Activation

When you use a chunk, its activation level goes up.

Base Activation

No matter what you happen to be thinking about today, certain memories are more easily retrieved than others in general. A chunk's activation can decay until it reaches its base level. When we refer to "activation," we mean the current activation, and if we mean the base activation, we will call it as such.

To raise the base level activation, the agent tries to add a new chunk to declarative memory, but that chunk already exists. So the agent either adds a new chunk to the declarative memory, or increases the base activation of the same chunk that already exists there.

Spreading Activation

Memories activate other memories they are related to (the "targets.") This is called "spreading activation." We'll talk about it happening from a source memory to target memories. When a source activates a target, the source does not lose activation.

How does Python ACT-R determine targets? It ignores slot names, and uses values. If a chunk contains the same symbol that is in the source, then that chunk is a target. This is Python ACT-R's implementation of semantic priming.

Only retrieved chunks are sources. Targets do not become sources unless they are retrieved.

There are also associative targets in Python ACT-R. That is, two things experienced simultaneously are connected by association, even if there's no relation between them (like has-a, or isa-a).

How much is spread? It's a function of a few things, including the strength of association between the two chunks.

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers"); } } catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + '
Skip to content

Declarative Memory

githubjimmyd edited this page Mar 6, 2019 · 20 revisions

In the psychological theory that ACT-R uses, humans have many memory types.

Some memories are of fact-like beliefs, such as that whales are mammals, or that Moskow is the capital of Russia. These kinds of memories are fact-like (propositional), and we can often retrieve them and be consciously aware of them. Other kinds of memory might be associations between concepts (associative memories), or memories of how to do things (procedural memory).

In ACT-R, the declarative memory is distinct from the procedural memory (which is the set of productions.)

Each declarative memory is called a "chunk."

The ACT-R agent requests a memory from the long-term declarative memory store, and retrieved memories go into the declarative memory buffer. We can think of this buffer's size as being able to hold about 2 to 6 chunks (often referred to as "four plus or minus two.")

For example, an agent might want to recall the capital of Russia. They might submit a request to declarative memory that looks like this:

Country: Russia Capital: ?

If the agent knows that Moskow is the capital of Russia, then the full "chunk" will be put in declarative memory.

Country: Russia Capital: Moskow

A request production puts a copy of the chunk in the declarative memory buffer, and another production will be activated in order to use it for anything.

Activation

Your ability to retrieve a declarative memory is determined by its current activation level ("activation.") If the activation of a particular chunk is below the threshold, it cannot be retrieved. Higher activations are more quickly retrieved. The threshold can move up and down, depending on the agent's focus.

According to ACT-R theory, the brain updates the activation of all memories all the time. But this is computationally expensive, so the implemented versions of ACT-R simplify this so computers can actually run it.

Activation can be turned on or off.

Noise

The brain is a wet, biological system. The current activation level of a chunk is subject to some noise. In Python ACT-R, noise is just about always set to 0.3.

Decay

Activation goes down over time. This is known as decay. It follows a classic "forgetting curve;" a negative exponential. It will continue to do this until it asymptotes to the base level activation (see below).

Image from https://blog.wranx.com/ebbinghaus-forgetting-curve

In the real world, decay happens, but often declarative memories in the declarative memory buffer are pushed out by other retrieved memories. Some think of this decay as a stand-in for interference from other memories, but rather than modelling these distractions, we just approximate it with decay.

Increasing Activation

When you use a chunk, its activation level goes up.

Base Activation

No matter what you happen to be thinking about today, certain memories are more easily retrieved than others in general. A chunk's activation can decay until it reaches its base level. When we refer to "activation," we mean the current activation, and if we mean the base activation, we will call it as such.

To raise the base level activation, the agent tries to add a new chunk to declarative memory, but that chunk already exists. So the agent either adds a new chunk to the declarative memory, or increases the base activation of the same chunk that already exists there.

Spreading Activation

Memories activate other memories they are related to (the "targets.") This is called "spreading activation." We'll talk about it happening from a source memory to target memories. When a source activates a target, the source does not lose activation.

How does Python ACT-R determine targets? It ignores slot names, and uses values. If a chunk contains the same symbol that is in the source, then that chunk is a target. This is Python ACT-R's implementation of semantic priming.

Only retrieved chunks are sources. Targets do not become sources unless they are retrieved.

There are also associative targets in Python ACT-R. That is, two things experienced simultaneously are connected by association, even if there's no relation between them (like has-a, or isa-a).

How much is spread? It's a function of a few things, including the strength of association between the two chunks.

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode"); } } catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); } })(); })();
Skip to content

Declarative Memory

githubjimmyd edited this page Mar 6, 2019 · 20 revisions

In the psychological theory that ACT-R uses, humans have many memory types.

Some memories are of fact-like beliefs, such as that whales are mammals, or that Moskow is the capital of Russia. These kinds of memories are fact-like (propositional), and we can often retrieve them and be consciously aware of them. Other kinds of memory might be associations between concepts (associative memories), or memories of how to do things (procedural memory).

In ACT-R, the declarative memory is distinct from the procedural memory (which is the set of productions.)

Each declarative memory is called a "chunk."

The ACT-R agent requests a memory from the long-term declarative memory store, and retrieved memories go into the declarative memory buffer. We can think of this buffer's size as being able to hold about 2 to 6 chunks (often referred to as "four plus or minus two.")

For example, an agent might want to recall the capital of Russia. They might submit a request to declarative memory that looks like this:

Country: Russia Capital: ?

If the agent knows that Moskow is the capital of Russia, then the full "chunk" will be put in declarative memory.

Country: Russia Capital: Moskow

A request production puts a copy of the chunk in the declarative memory buffer, and another production will be activated in order to use it for anything.

Activation

Your ability to retrieve a declarative memory is determined by its current activation level ("activation.") If the activation of a particular chunk is below the threshold, it cannot be retrieved. Higher activations are more quickly retrieved. The threshold can move up and down, depending on the agent's focus.

According to ACT-R theory, the brain updates the activation of all memories all the time. But this is computationally expensive, so the implemented versions of ACT-R simplify this so computers can actually run it.

Activation can be turned on or off.

Noise

The brain is a wet, biological system. The current activation level of a chunk is subject to some noise. In Python ACT-R, noise is just about always set to 0.3.

Decay

Activation goes down over time. This is known as decay. It follows a classic "forgetting curve;" a negative exponential. It will continue to do this until it asymptotes to the base level activation (see below).

Image from https://blog.wranx.com/ebbinghaus-forgetting-curve

In the real world, decay happens, but often declarative memories in the declarative memory buffer are pushed out by other retrieved memories. Some think of this decay as a stand-in for interference from other memories, but rather than modelling these distractions, we just approximate it with decay.

Increasing Activation

When you use a chunk, its activation level goes up.

Base Activation

No matter what you happen to be thinking about today, certain memories are more easily retrieved than others in general. A chunk's activation can decay until it reaches its base level. When we refer to "activation," we mean the current activation, and if we mean the base activation, we will call it as such.

To raise the base level activation, the agent tries to add a new chunk to declarative memory, but that chunk already exists. So the agent either adds a new chunk to the declarative memory, or increases the base activation of the same chunk that already exists there.

Spreading Activation

Memories activate other memories they are related to (the "targets.") This is called "spreading activation." We'll talk about it happening from a source memory to target memories. When a source activates a target, the source does not lose activation.

How does Python ACT-R determine targets? It ignores slot names, and uses values. If a chunk contains the same symbol that is in the source, then that chunk is a target. This is Python ACT-R's implementation of semantic priming.

Only retrieved chunks are sources. Targets do not become sources unless they are retrieved.

There are also associative targets in Python ACT-R. That is, two things experienced simultaneously are connected by association, even if there's no relation between them (like has-a, or isa-a).

How much is spread? It's a function of a few things, including the strength of association between the two chunks.

Clone this wiki locally