babi_qa

Referências:

pt-qa1

Use o seguinte comando para carregar este conjunto de dados no TFDS:

ds = tfds.load('huggingface:babi_qa/en-qa1')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa2

Use o seguinte comando para carregar este conjunto de dados no TFDS:

ds = tfds.load('huggingface:babi_qa/en-qa2')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa3

Use o seguinte comando para carregar este conjunto de dados no TFDS:

ds = tfds.load('huggingface:babi_qa/en-qa3')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa4

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa4')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa5

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa5')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa6

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa6')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa7

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa7')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa8

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa8')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa9

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa9')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa10

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa10')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa11

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa11')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa12

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa12')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa13

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa13')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa14

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa14')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa15

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa15')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 250
'train' 250
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa16

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa16')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa17

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa17')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 125
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa18

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa18')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 199
'train' 198
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa19

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa19')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-qa20

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-qa20')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 93
'train' 94
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa1')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa2')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa3')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 167
'train' 167
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa4')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa5')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa6')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa7')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa8')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa9')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa10')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa11')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa12')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa13')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 125
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa14')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa15')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 250
'train' 250
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa16')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa17')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 125
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa18')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 198
'train' 198
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa19')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-qa20')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 94
'train' 93
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa1

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa1')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa2

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa2')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa3

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa3')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa4

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa4')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa5

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa5')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa6

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa6')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa7

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa7')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa8

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa8')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa9

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa9')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa10

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa10')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa11

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa11')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa12

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa12')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa13

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa13')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa14

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa14')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa15

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa15')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 250
'train' 2500
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa16

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa16')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa17

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa17')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 1250
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa18

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa18')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 199
'train' 1978
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa19

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa19')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

pt-10k-qa20

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-10k-qa20')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 93
'train' 933
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa1

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa1')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa2

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa2')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa3

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa3')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa4

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa4')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 900
'validation' 100
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa5

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa5')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa6

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa6')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa7

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa7')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa8

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa8')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa9

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa9')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa10

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa10')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa11')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa12')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa13

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa13')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa14

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa14')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 180
'validation' 20
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa15

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa15')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 250
'train' 225
'validation' 25
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa16

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa16')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 900
'validation' 100
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa17

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa17')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 113
'validation' 12
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa18

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa18')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 199
'train' 179
'validation' 19
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa19

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa19')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 900
'validation' 100
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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-válido-qa20

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-qa20')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 93
'train' 85
'validation' 9
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa1')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa2')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa3')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa4')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 9.000
'validation' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa5')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa6')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa7')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa8')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa9')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa10')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa11')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa12')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa13')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa14')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 1800
'validation' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa15')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 250
'train' 2250
'validation' 250
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa16')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 9.000
'validation' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa17')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 1125
'validation' 125
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa18')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 199
'train' 1781
'validation' 197
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa19')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 9.000
'validation' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/en-valid-10k-qa20')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 93
'train' 840
'validation' 93
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa1')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa2')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa3')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 167
'train' 1667
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa4')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa5')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa6')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa7')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa8')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa9')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa10')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa11')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa12')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa13')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 1250
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa14')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa15')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 250
'train' 2500
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa16')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa17')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 1250
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa18')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 198
'train' 1977
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa19')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "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

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/hn-10k-qa20')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 94
'train' 934
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa1

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa1')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa2

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa2')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa3

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa3')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa4

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa4')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa5

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa5')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa6

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa6')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa7

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa7')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa8

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa8')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa9

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa9')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa10

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa10')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa11

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa11')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa12

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa12')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa13

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa13')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa14

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa14')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 200
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa15

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa15')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 250
'train' 250
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa16

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa16')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa17

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa17')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 125
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa18

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa18')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 199
'train' 198
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa19

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa19')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 1000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-qa20

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-qa20')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 93
'train' 94
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa1

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa1')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa2

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa2')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa3

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa3')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa4

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa4')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa5

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa5')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa6

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa6')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa7

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa7')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa8

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa8')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa9

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa9')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa10

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa10')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa11

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa11')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa12

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa12')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa13

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa13')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa14

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa14')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 200
'train' 2000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa15

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa15')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 250
'train' 2500
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa16

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa16')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa17

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa17')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 125
'train' 1250
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa18

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa18')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 199
'train' 1978
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa19

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa19')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 1000
'train' 10.000
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}

embaralhado-10k-qa20

Use o seguinte comando para carregar este conjunto de dados no TFDS: 

ds = tfds.load('huggingface:babi_qa/shuffled-10k-qa20')
  • Descrição : 
The (20) QA bAbI tasks are a set of proxy tasks that evaluate reading
comprehension via question answering. Our tasks measure understanding
in several ways: whether a system is able to answer questions via chaining facts,
simple induction, deduction and many more. The tasks are designed to be prerequisites
for any system that aims to be capable of conversing with a human.
The aim is to classify these tasks into skill sets,so that researchers
can identify (and then rectify)the failings of their systems.
  • Licença : Licença Creative Commons Atribuição 3.0
  • Versão : 1.2.0
  • Divisões :
Dividir Exemplos
'test' 93
'train' 933
  • Características : 
{
    "story": {
        "feature": {
            "id": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "type": {
                "num_classes": 2,
                "names": [
                    "context",
                    "question"
                ],
                "names_file": null,
                "id": null,
                "_type": "ClassLabel"
            },
            "text": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            },
            "supporting_ids": {
                "feature": {
                    "dtype": "string",
                    "id": null,
                    "_type": "Value"
                },
                "length": -1,
                "id": null,
                "_type": "Sequence"
            },
            "answer": {
                "dtype": "string",
                "id": null,
                "_type": "Value"
            }
        },
        "length": -1,
        "id": null,
        "_type": "Sequence"
    }
}