Formatação de dados para projeção em um repositório de conhecimento

No Azure AI Search, "formatação de dados" descreve uma etapa no fluxo de trabalho do repositório de conhecimento que cria uma representação de dados do conteúdo que você deseja projetar em tabelas, objetos e arquivos no Armazenamento do Azure.

Conforme as habilidades são executadas, as saídas são gravadas em uma árvore de enriquecimento em uma hierarquia de nós. Embora seja possível visualizar e consumir a árvore de enriquecimento em sua totalidade, é mais provável que você queira uma granularidade mais alta, criando subconjuntos de nós para cenários diferentes, como colocar os nós relacionados ao texto traduzido ou às entidades extraídas em tabelas específicas.

Por si só, a árvore de enriquecimento não inclui uma lógica que informe como o conteúdo dela é representado em um repositório de conhecimento. As formas de dados preenchem essa lacuna fornecendo o esquema do que entra em cada tabela, objeto e projeção de arquivo. É possível pensar em uma forma de dados como uma visualização ou definição personalizada dos dados enriquecidos. É possível criar quantas formas forem necessárias e atribuí-las a projeções em uma definição do repositório de conhecimento.

Abordagens para criar formas

Há duas maneiras de moldar o conteúdo enriquecido para projeção em um repositório de conhecimento:

• Use a habilidade de formatação para criar nós em uma árvore de enriquecimento que serão usados expressamente para a projeção. A maioria das habilidades cria novos conteúdos. Em comparação, uma habilidade de formatação trabalha com nós existentes, geralmente para consolidar diversos nós em um único objeto complexo. Isso é útil para tabelas, onde você deseja que a saída de diversos nós seja fisicamente expressa como colunas da tabela.

• Use uma forma embutida na própria definição da projeção.

Ao usar a habilidade de formatação, a forma é externalizada para uso por diversas projeções ou até mesmo por outras habilidades. Isso também garante que todas as mutações da árvore de enriquecimento estejam contidas na habilidade e que a saída seja um objeto que possa ser reutilizado. Em contraste, a formatação embutida permite criar a forma que você precisa, mas é um objeto anônimo e está disponível apenas para a projeção para a qual está definida.

As abordagens podem ser usadas juntas ou separadamente. Este artigo mostra ambos: uma habilidade de formatação para as projeções de tabela e a formatação embutida com a projeção da tabela de frases importantes.

Use uma habilidade de formatação

As habilidades de formatação são geralmente colocadas no final de um conjunto de habilidades, criando uma visão dos dados que você deseja transmitir a uma projeção. Este exemplo cria uma forma chamada "tableprojection" que contém os seguintes nós: "reviews_text", "reviews_title", "AzureSearch_DocumentKey", além de pontuações de sentimento e frases importantes de comentários paginados.

{
    "@odata.type": "#Microsoft.Skills.Util.ShaperSkill",
    "name": "#5",
    "description": null,
    "context": "/document",
    "inputs": [        
        {
            "name": "reviews_text",
            "source": "/document/reviews_text",
            "sourceContext": null,
            "inputs": []
        },
        {
            "name": "reviews_title",
            "source": "/document/reviews_title",
            "sourceContext": null,
            "inputs": []
        },
        {
            "name": "AzureSearch_DocumentKey",
            "source": "/document/AzureSearch_DocumentKey",
            "sourceContext": null,
            "inputs": []
        },  
        {
            "name": "pages",
            "source": null,
            "sourceContext": "/document/reviews_text/pages/*",
            "inputs": [
                {
                    "name": "Sentiment",
                    "source": "/document/reviews_text/pages/*/Sentiment",
                    "sourceContext": null,
                    "inputs": []
                },
                {
                    "name": "LanguageCode",
                    "source": "/document/Language",
                    "sourceContext": null,
                    "inputs": []
                },
                {
                    "name": "Page",
                    "source": "/document/reviews_text/pages/*",
                    "sourceContext": null,
                    "inputs": []
                },
                {
                    "name": "keyphrase",
                    "sourceContext": "/document/reviews_text/pages/*/Keyphrases/*",
                    "inputs": [
                        {
                            "source": "/document/reviews_text/pages/*/Keyphrases/*",
                            "name": "Keyphrases"
                        }
                    ]
                }
            ]
        }
    ],
    "outputs": [
        {
            "name": "output",
            "targetName": "tableprojection"
        }
    ]
}

Propriedade SourceContext

Em uma habilidade de formatação, uma entrada pode ter um elemento sourceContext. Essa mesma propriedade também pode ser usada em formas embutidas nas projeções.

sourceContext é usado para criar objetos aninhados de diversos níveis em um pipeline de enriquecimento. Se a entrada estiver em um contexto diferente do contexto da habilidade, use a sourceContext. A sourceContext exige que você defina uma entrada aninhada com o elemento específico que está sendo endereçado como a origem.

No exemplo acima, a análise de sentimento e a extração de frases importantes foram realizadas em um texto que foi dividido em páginas para melhorar a eficiência da análise. Supondo que você deseja que as pontuações e frases sejam projetadas em uma tabela, agora você precisa definir o contexto para a entrada aninhada que forneça a pontuação e a frase.

Projetar uma forma em diversas tabelas

Com o nó tableprojection definido na seção outputs acima, é possível dividir partes do nó tableprojection em tabelas relacionadas individuais:

"projections": [
    {
        "tables": [
            {
                "tableName": "hotelReviewsDocument",
                "generatedKeyName": "Documentid",
                "source": "/document/tableprojection"
            },
            {
                "tableName": "hotelReviewsPages",
                "generatedKeyName": "Pagesid",
                "source": "/document/tableprojection/pages/*"
            },
            {
                "tableName": "hotelReviewsKeyPhrases",
                "generatedKeyName": "KeyPhrasesid",
                "source": "/document/tableprojection/pages/*/keyphrase/*"
            }
        ]
    }
]

Forma embutida para projeções de tabela

A formatação embutida é a capacidade de criar novas formas na própria definição de projeção. A formatação embutida tem estas características:

• A formatação só pode ser usada pela projeção que a contém.
• A formatação pode ser idêntica ao que seria produzido pela habilidade de formatação.

Uma formatação embutida é criada usando sourceContext e inputs .

Para projetar os mesmos dados do exemplo anterior, a opção de projeção embutida seria assim:

"projections": [
    {
        "tables": [
            {
                "tableName": "hotelReviewsInlineDocument",
                "generatedKeyName": "Documentid",
                "sourceContext": "/document",     
                "inputs": [
                    {
                        "name": "reviews_text",
                        "source": "/document/reviews_text"
                    },
                    {
                        "name": "reviews_title",
                        "source": "/document/reviews_title"
                    },
                    {
                        "name": "AzureSearch_DocumentKey",
                        "source": "/document/AzureSearch_DocumentKey"
                    }                             
                ]
            },
            {
                "tableName": "hotelReviewsInlinePages",
                "generatedKeyName": "Pagesid",
                "sourceContext": "/document/reviews_text/pages/*",
                "inputs": [
                        {
                    "name": "Sentiment",
                    "source": "/document/reviews_text/pages/*/Sentiment"
                    },
                    {
                        "name": "LanguageCode",
                        "source": "/document/Language"
                    },
                    {
                        "name": "Page",
                        "source": "/document/reviews_text/pages/*"
                    }
                ]
            },
            {
                "tableName": "hotelReviewsInlineKeyPhrases",
                "generatedKeyName": "KeyPhraseId",
                "sourceContext": "/document/reviews_text/pages/*/Keyphrases/*",
                "inputs": [
                    {
                        "name": "Keyphrases",
                        "source": "/document/reviews_text/pages/*/Keyphrases/*"
                    }
                ]
            }
        ]
    }
]

Uma observação de ambas as abordagens é a maneira como os valores de "Keyphrases" são projetados usando o "sourceContext". O nó "Keyphrases", que contém uma coleção de cadeias de caracteres, é filho do texto da página. No entanto, como as projeções exigem um objeto JSON e a página é do tipo primitivo (cadeia de caracteres), "sourceContext" é usado para encapsular a frase importante em um objeto com uma propriedade nomeada. Essa técnica permite que mesmo tipos primitivos sejam projetados independentemente.

Forma embutida para projeções de objeto

Você pode gerar uma nova forma usando a habilidade do Shaper ou usando a formação embutida da projeção do objeto. Embora o exemplo de tabelas tenha demonstrado a abordagem de criação de uma forma e de divisão, este exemplo demonstra o uso de shaping embutido.

O shaping embutido é a capacidade de criar uma nova forma na definição das entradas para uma projeção. O shaping embutido cria um objeto anônimo, que é idêntico ao que uma habilidade do Shaper produziria (nesse caso, projectionShape). O ajuste em linha será útil se você estiver definindo uma forma que não planeja reutilizar.

A propriedade de projeções é uma matriz. Este exemplo adiciona uma nova instância de projeção à matriz, em que a definição knowledgeStore contém projeções embutidas. Ao usar projeções embutidas, você poderá omitir a habilidade do Shaper.

"knowledgeStore" : {
    "storageConnectionString": "DefaultEndpointsProtocol=https;AccountName=<Acct Name>;AccountKey=<Acct Key>;",
    "projections": [
            {
            "tables": [ ],
            "objects": [
                {
                    "storageContainer": "sampleobject",
                    "source": null,
                    "generatedKeyName": "myobject",
                    "sourceContext": "/document",
                    "inputs": [
                        {
                            "name": "metadata_storage_name",
                            "source": "/document/metadata_storage_name"
                        },
                        {
                            "name": "metadata_storage_path",
                            "source": "/document/metadata_storage_path"
                        },
                        {
                            "name": "content",
                            "source": "/document/content"
                        },
                        {
                            "name": "keyPhrases",
                            "source": "/document/merged_content/keyphrases/*"
                        },
                        {
                            "name": "entities",
                            "source": "/document/merged_content/entities/*/name"
                        },
                        {
                            "name": "ocrText",
                            "source": "/document/normalized_images/*/text"
                        },
                        {
                            "name": "ocrLayoutText",
                            "source": "/document/normalized_images/*/layoutText"
                        }
                    ]

                }
            ],
            "files": []
        }
    ]
}

Próximas etapas

Este artigo descreve os conceitos e os princípios das formas de projeção. Como uma próxima etapa, veja como eles são aplicados em padrões para projeções de tabelas, objetos e arquivos.