Compartilhar via

Visualização do notebook no Microsoft Fabric

  • Artigo

O Microsoft Fabric é um serviço de análise integrada que acelera o tempo de descoberta de insights entre data warehouses e sistemas de análise de Big Data. A visualização de dados em notebooks é um componente chave que permite obter insights sobre seus dados. Ele ajuda a facilitar o entendimento para pessoas de dados grandes e pequenos. Ele também facilita a detecção de padrões, tendências e exceções em grupos de dados.

Quando você usa o Apache Spark no Fabric, há várias opções internas para ajudá-lo a visualizar seus dados, incluindo opções de gráfico de notebook do Fabric e acesso a bibliotecas populares de código aberto.

Ao usar um notebook do Fabric, transforme sua exibição de resultados tabulares em um gráfico personalizado usando opções de gráfico. Aqui, você pode visualizar seus dados sem precisar escrever nenhum código.

Comando de visualização integrado - função display()

A função de exibição integrada do Fabric permite transformar DataFrames do Apache Spark, Dataframes do Pandas e resultados de consultas SQL em visualizações de dados avançadas.

Você pode usar a função display em dataframes criados no PySpark e no Scala em DataFrames do Spark ou funções de RDD (Conjuntos de Dados Distribuídos Resilientes) para produzir os modos de exibição em tabela e gráfico avançados de dataframes.

A saída da instrução SQL aparece na exibição de tabela renderizada por padrão.

Modo de exibição de tabela de dataframe avançado

GIF animado de visualização rica de dataframe.

  1. O modo de exibição de tabela é renderizado por padrão com o comando display().
  2. Você pode criar o perfil do seu dataframe clicando no botão Inspecionar. Ele fornece a distribuição de dados resumida e mostra estatísticas de cada coluna.
  3. Cada cartão no painel lateral "Inspecionar" mapeia para uma coluna do dataframe, e você pode exibir mais detalhes clicando no cartão ou selecionando uma coluna na tabela.
  4. Você pode exibir os detalhes da célula clicando na célula da tabela. Isso é útil quando o dataframe contém um tipo de conteúdo de sequência longa.
  5. Você pode especificar a contagem de linhas do modo de exibição de tabela, o valor padrão é 1000, suporte do Notebook para exibir e criar o perfil de 10000 linhas de um quadro de dados no máximo.

Modo de exibição de gráfico de dataframe avançado

GIF animado da visualização gráfica.

  1. Quando você tiver uma exibição de tabela renderizada, alterne para a exibição em Gráfico.

  2. O Notebook do Fabric recomendará automaticamente um par "Chave" "Valor" com base no dataframe de destino para tornar o gráfico padrão significativo com insights de dados.

  3. Agora você pode personalizar sua visualização especificando os seguintes valores:

    Configuration Descrição
    Tipo de gráfico A função "display" dá suporte a uma ampla variedade de tipos de gráfico, incluindo gráficos de barras, gráficos de dispersão, gráficos de linhas e muito mais.
    Chave Especificar o intervalo de valores para o eixo x.
    Valor Especificar o intervalo de valores para os valores do eixo y.
    Grupo de séries Use esta configuração para determinar os grupos para a agregação.
    Agregação Use este método para agregar dados em sua visualização.

    As configurações serão salvas automaticamente no conteúdo de saída do Notebook.

    Observação

    Por padrão, a função display(df) usará apenas as primeiras 1000 linhas dos dados para renderizar os gráficos. Selecione a Agregação em todos os resultados e selecione Aplicar para aplicar a geração de gráfico do modelo semântico inteiro. Um trabalho do Spark será acionado quando a configuração do gráfico for alterada. Observe que pode levar vários minutos para concluir o cálculo e renderizar o gráfico.

  4. Ao concluir o trabalho, você poderá exibir e interagir com sua visualização final.

Exibição resumida do display(df)

Use display(df, summary = true) para verificar o resumo de estatísticas de um determinado de DataFrame do Apache Spark. O resumo inclui o nome da coluna, o tipo de coluna, os valores exclusivos e os valores ausentes para cada coluna. Você também pode selecionar uma coluna específica para ver seu valor mínimo, valor máximo, valor médio e desvio padrão.

GIF animado da visualização resumida.

opção displayHTML()

Os notebooks do Fabric dão suporte a elementos gráficos HTML usando a função de displayHTML.

A imagem a seguir é um exemplo de criação de visualizações usando D3.js.

Captura de tela de um exemplo de gráfico criado com o D3.js.

Para criar essa visualização, execute o código a seguir.

displayHTML("""<!DOCTYPE html>
<meta charset="utf-8">

<!-- Load d3.js -->
<script src="https://d3js.org/d3.v4.js"></script>

<!-- Create a div where the graph will take place -->
<div id="my_dataviz"></div>
<script>

// set the dimensions and margins of the graph
var margin = {top: 10, right: 30, bottom: 30, left: 40},
  width = 400 - margin.left - margin.right,
  height = 400 - margin.top - margin.bottom;

// append the svg object to the body of the page
var svg = d3.select("#my_dataviz")
.append("svg")
  .attr("width", width + margin.left + margin.right)
  .attr("height", height + margin.top + margin.bottom)
.append("g")
  .attr("transform",
        "translate(" + margin.left + "," + margin.top + ")");

// Create Data
var data = [12,19,11,13,12,22,13,4,15,16,18,19,20,12,11,9]

// Compute summary statistics used for the box:
var data_sorted = data.sort(d3.ascending)
var q1 = d3.quantile(data_sorted, .25)
var median = d3.quantile(data_sorted, .5)
var q3 = d3.quantile(data_sorted, .75)
var interQuantileRange = q3 - q1
var min = q1 - 1.5 * interQuantileRange
var max = q1 + 1.5 * interQuantileRange

// Show the Y scale
var y = d3.scaleLinear()
  .domain([0,24])
  .range([height, 0]);
svg.call(d3.axisLeft(y))

// a few features for the box
var center = 200
var width = 100

// Show the main vertical line
svg
.append("line")
  .attr("x1", center)
  .attr("x2", center)
  .attr("y1", y(min) )
  .attr("y2", y(max) )
  .attr("stroke", "black")

// Show the box
svg
.append("rect")
  .attr("x", center - width/2)
  .attr("y", y(q3) )
  .attr("height", (y(q1)-y(q3)) )
  .attr("width", width )
  .attr("stroke", "black")
  .style("fill", "#69b3a2")

// show median, min and max horizontal lines
svg
.selectAll("toto")
.data([min, median, max])
.enter()
.append("line")
  .attr("x1", center-width/2)
  .attr("x2", center+width/2)
  .attr("y1", function(d){ return(y(d))} )
  .attr("y2", function(d){ return(y(d))} )
  .attr("stroke", "black")
</script>

"""
)

Inserir um relatório do Power BI em um notebook

Importante

Esse recurso está em VERSÃO PRÉVIA no momento. Estas informações estão relacionadas a um produto de pré-lançamento, que pode ser bastante modificado antes de ser lançado. A Microsoft não faz nenhuma garantia, expressa ou implícita, com relação às informações fornecidas aqui.

O pacote Powerbiclient do Python agora tem suporte nativo em notebooks do Fabric. Não é necessário fazer nenhuma configuração extra (como o processo de autenticação) no runtime do Spark do Notebook Fabric 3.4. Basta importar powerbiclient e continuar sua exploração. Para saber mais sobre como usar o pacote powerbiclient, consulte a documentação powerbiclient.

O powerbiclient dá suporte aos seguintes principais recursos.

Renderizar um relatório existente do Power BI

É possível inserir e interagir facilmente com relatórios do Power BI nos notebooks com apenas algumas linhas de código.

A imagem a seguir é um exemplo de renderização do relatório existente do Power BI.

Captura de tela de um visual rápido de faísca.

Execute o código a seguir para renderizar um relatório existente do Power BI.

from powerbiclient import Report

report_id="Your report id"
report = Report(group_id=None, report_id=report_id)

report

Criar visuais de relatório a partir de um DataFrame do Spark

Use um DataFrame do Spark em seu notebook para gerar visualizações perspicazes rapidamente. Também poderá selecionar Salvar no relatório inserido para criar um item de relatório em um espaço de trabalho de destino.

A imagem a seguir é um exemplo de um QuickVisualize() a partir de um DataFrame do Spark.

Captura de tela de um relatório do Power BI.

Execute o código a seguir para renderizar um relatório de um DataFrame do Spark.

# Create a spark dataframe from a Lakehouse parquet table
sdf = spark.sql("SELECT * FROM testlakehouse.table LIMIT 1000")

# Create a Power BI report object from spark data frame
from powerbiclient import QuickVisualize, get_dataset_config
PBI_visualize = QuickVisualize(get_dataset_config(sdf))

# Render new report
PBI_visualize

Criar visuais de relatório a partir de um DataFrame do pandas

Também poderá criar relatórios com base em um DataFrame do pandas no notebook.

A imagem a seguir é um exemplo de um QuickVisualize() a partir de um DataFrame do pandas.

Captura de tela de um visual rápido de pandas.

Execute o código a seguir para renderizar um relatório de um DataFrame do Spark.

import pandas as pd

# Create a pandas dataframe from a URL
df = pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/fips-unemp-16.csv")

# Create a pandas dataframe from a Lakehouse csv file
from powerbiclient import QuickVisualize, get_dataset_config

# Create a Power BI report object from your data
PBI_visualize = QuickVisualize(get_dataset_config(df))

# Render new report
PBI_visualize

Quando se trata de visualização de dados, o Python oferece várias bibliotecas de gráficos que vêm incluídas com muitos recursos diferentes. Por padrão, cada pool do Apache Spark no Fabric contém um conjunto de bibliotecas de código aberto populares e selecionadas.

Matplotlib

Você pode renderizar bibliotecas de plotagem padrão, como Matplotlib, usando as funções de renderização internas para cada biblioteca.

A imagem a seguir é um exemplo de criação de um gráfico de barras usando Matplotlib.

Captura de tela de um gráfico de linhas criado com o Matplotlib.

Captura de tela de um gráfico de barras criado com o Matplotlib.

Execute o código de exemplo a seguir para desenhar esse gráfico de barras.

# Bar chart

import matplotlib.pyplot as plt

x1 = [1, 3, 4, 5, 6, 7, 9]
y1 = [4, 7, 2, 4, 7, 8, 3]

x2 = [2, 4, 6, 8, 10]
y2 = [5, 6, 2, 6, 2]

plt.bar(x1, y1, label="Blue Bar", color='b')
plt.bar(x2, y2, label="Green Bar", color='g')
plt.plot()

plt.xlabel("bar number")
plt.ylabel("bar height")
plt.title("Bar Chart Example")
plt.legend()
plt.show()

Bokeh

Você pode renderizar bibliotecas HTML ou interativas, como a bokeh, usando displayHTML(df).

A imagem a seguir é um exemplo de como plotar glifos em um mapa usando bokeh.

Captura de tela de um exemplo de plotagem de glifos em um mapa.

Para desenhar esta imagem, execute o código de exemplo a seguir.

from bokeh.plotting import figure, output_file
from bokeh.tile_providers import get_provider, Vendors
from bokeh.embed import file_html
from bokeh.resources import CDN
from bokeh.models import ColumnDataSource

tile_provider = get_provider(Vendors.CARTODBPOSITRON)

# range bounds supplied in web mercator coordinates
p = figure(x_range=(-9000000,-8000000), y_range=(4000000,5000000),
           x_axis_type="mercator", y_axis_type="mercator")
p.add_tile(tile_provider)

# plot datapoints on the map
source = ColumnDataSource(
    data=dict(x=[ -8800000, -8500000 , -8800000],
              y=[4200000, 4500000, 4900000])
)

p.circle(x="x", y="y", size=15, fill_color="blue", fill_alpha=0.8, source=source)

# create an html document that embeds the Bokeh plot
html = file_html(p, CDN, "my plot1")

# display this html
displayHTML(html)

Plotly

Você pode renderizar bibliotecas HTML ou interativas, como a Plotly, usando displayHTML() .

Para desenhar esta imagem, execute o código de exemplo a seguir.

Captura de tela de um mapa dos Estados Unidos criado com o plotly. 

from urllib.request import urlopen
import json
with urlopen('https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json') as response:
    counties = json.load(response)

import pandas as pd
df = pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/fips-unemp-16.csv",
                   dtype={"fips": str})

import plotly
import plotly.express as px

fig = px.choropleth(df, geojson=counties, locations='fips', color='unemp',
                           color_continuous_scale="Viridis",
                           range_color=(0, 12),
                           scope="usa",
                           labels={'unemp':'unemployment rate'}
                          )
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})

# create an html document that embeds the Plotly plot
h = plotly.offline.plot(fig, output_type='div')

# display this html
displayHTML(h)

Pandas

Exibia a saída HTML de DataFrames do pandas como a saída padrão. Os notebooks do Fabric mostram automaticamente o conteúdo HTML com estilo.

Captura de tela de uma tabela criada com o pandas. 

import pandas as pd 
import numpy as np 

df = pd.DataFrame([[38.0, 2.0, 18.0, 22.0, 21, np.nan],[19, 439, 6, 452, 226,232]], 

                  index=pd.Index(['Tumour (Positive)', 'Non-Tumour (Negative)'], name='Actual Label:'), 

                  columns=pd.MultiIndex.from_product([['Decision Tree', 'Regression', 'Random'],['Tumour', 'Non-Tumour']], names=['Model:', 'Predicted:'])) 

df

Conteúdo relacionado