참고자료:
en-qa1
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa1')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa2
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa2')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa3
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa3')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa4
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa4')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa5
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa5')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa6
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa6')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa7
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa7')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa8
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa8')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa9
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa9')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa10
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa10')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa11
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa11')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa12
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa12')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa13
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa13')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa14
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa14')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa15
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa15')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 250 |
'train' | 250 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa16
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa16')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa17
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa17')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 125 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa18
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa18')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 199 |
'train' | 198 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa19
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa19')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-qa20
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-qa20')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 93 |
'train' | 94 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa1
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa1')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa2
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa2')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa3
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa3')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 167 |
'train' | 167 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa4
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa4')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa5
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa5')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa6
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa6')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa7
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa7')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa8
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa8')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa9
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa9')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa10
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa10')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa11
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa11')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa12
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa12')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa13
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa13')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 125 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa14
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa14')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa15
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa15')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 250 |
'train' | 250 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa16
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa16')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa17
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa17')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 125 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa18
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa18')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 198 |
'train' | 198 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa19
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa19')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-qa20
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-qa20')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 94 |
'train' | 93 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa1
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa1')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa2
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa2')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa3
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa3')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa4
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa4')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa5
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa5')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa6
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa6')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa7
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa7')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa8
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa8')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa9
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa9')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa10
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa10')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa11
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa11')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa12
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa12')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa13
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa13')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa14
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa14')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa15
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa15')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 250 |
'train' | 2500 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa16
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa16')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa17
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa17')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 1250 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa18
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa18')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 199 |
'train' | 1978년 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa19
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa19')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-10k-qa20
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-10k-qa20')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 93 |
'train' | 933 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa1
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa1')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa2
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa2')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa3
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa3')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa4
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa4')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 900 |
'validation' | 100 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa5
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa5')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa6
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa6')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa7
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa7')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa8
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa8')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa9
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa9')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa10
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa10')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa11
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa11')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa12
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa12')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa13
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa13')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa14
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa14')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 180 |
'validation' | 20 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa15
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa15')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 250 |
'train' | 225 |
'validation' | 25 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa16
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa16')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 900 |
'validation' | 100 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa17
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa17')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 113 |
'validation' | 12 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa18
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa18')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 199 |
'train' | 179 |
'validation' | 19 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa19
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa19')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 900 |
'validation' | 100 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-qa20
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-qa20')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 93 |
'train' | 85 |
'validation' | 9 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa1
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa1')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa2
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa2')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa3
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa3')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa4
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa4')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 9000 |
'validation' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa5
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa5')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa6
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa6')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa7
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa7')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa8
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa8')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa9
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa9')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa10
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa10')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa11
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa11')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa12
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa12')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa13
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa13')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa14
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa14')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 1800 |
'validation' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa15
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa15')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 250 |
'train' | 2250 |
'validation' | 250 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa16
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa16')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 9000 |
'validation' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa17
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa17')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 1125 |
'validation' | 125 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa18
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa18')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 199 |
'train' | 1781년 |
'validation' | 197 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa19
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa19')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 9000 |
'validation' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
en-유효-10k-qa20
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa20')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 93 |
'train' | 840 |
'validation' | 93 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa1
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa1')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa2
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa2')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa3
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa3')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 167 |
'train' | 1667년 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa4
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa4')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa5
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa5')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa6
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa6')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa7
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa7')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa8
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa8')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa9
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa9')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa10
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa10')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa11
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa11')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa12
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa12')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa13
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa13')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 1250 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa14
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa14')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa15
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa15')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 250 |
'train' | 2500 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa16
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa16')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa17
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa17')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 1250 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa18
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa18')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 198 |
'train' | 1977년 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa19
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa19')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
hn-10k-qa20
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/hn-10k-qa20')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 94 |
'train' | 934 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인 qa1
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa1')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa2
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa2')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인 qa3
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa3')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa4
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa4')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa5
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa5')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa6
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa6')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa7
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa7')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa8
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa8')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa9
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa9')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa10
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa10')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa11
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa11')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa12
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa12')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa13
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa13')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa14
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa14')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 200 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa15
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa15')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 250 |
'train' | 250 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa16
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa16')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa17
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa17')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 125 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa18
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa18')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 199 |
'train' | 198 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa19
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa19')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 1000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-qa20
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-qa20')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 93 |
'train' | 94 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa1
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa1')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa2
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa2')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa3
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa3')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa4
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa4')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa5
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa5')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa6
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa6')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa7
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa7')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa8
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa8')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa9
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa9')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa10
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa10')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa11
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa11')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa12
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa12')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa13
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa13')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa14
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa14')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 200 |
'train' | 2000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa15
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa15')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 250 |
'train' | 2500 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa16
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa16')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa17
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa17')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 125 |
'train' | 1250 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa18
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa18')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 199 |
'train' | 1978년 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa19
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa19')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 1000 |
'train' | 10000 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}
섞인-10k-qa20
TFDS에 이 데이터세트를 로드하려면 다음 명령어를 사용하세요.
ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa20')
- 설명 :
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
- 라이센스 : 크리에이티브 커먼즈 저작자표시 3.0 라이센스
- 버전 : 1.2.0
- 분할 :
| 나뉘다 | 예 |
|---|---|
'test' | 93 |
'train' | 933 |
- 특징 :
{
"story": {
"feature": {
"id": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"type": {
"num_classes": 2,
"names": [
"context",
"question"
],
"names_file": null,
"id": null,
"_type": "ClassLabel"
},
"text": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"supporting_ids": {
"feature": {
"dtype": "string",
"id": null,
"_type": "Value"
},
"length": -1,
"id": null,
"_type": "Sequence"
},
"answer": {
"dtype": "string",
"id": null,
"_type": "Value"
}
},
"length": -1,
"id": null,
"_type": "Sequence"
}
}