참조:
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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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"
}
}
엔카4
다음 명령을 사용하여 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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"
}
}
ko-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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-valid-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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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.
- 라이선스 : Creative Commons Attribution 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"
}
}