Esta página foi traduzida pela API Cloud Translation.
Switch to English

TensorFlow Validação de dados

Um exemplo de um componente chave da TensorFlow Extensão

Este notebook exemplo colab ilustra como TensorFlow Validação de dados (TFDV) pode ser usado para investigar e visualizar o seu conjunto de dados. Isso inclui a olhar para a estatística descritiva, inferindo um esquema, verificando e corrigindo anomalias, e verificação de deriva e de inclinação em nosso conjunto de dados. É importante entender as características do seu conjunto de dados, incluindo como ele pode mudar ao longo do tempo em sua linha de produção. Também é importante procurar anomalias em seus dados e comparar a sua formação, avaliação e servindo conjuntos de dados para se certificar de que eles são consistentes.

Usaremos dados do táxi Viagens conjunto de dados liberado pela cidade de Chicago.

Leia mais sobre o conjunto de dados no Google BigQuery . Explorar o conjunto de dados completo no UI BigQuery .

As colunas no conjunto de dados são:

pickup_community_area tarifa trip_start_month
trip_start_hour trip_start_day trip_start_timestamp
pickup_latitude pickup_longitude dropoff_latitude
dropoff_longitude trip_miles pickup_census_tract
dropoff_census_tract tipo de pagamento companhia
trip_seconds dropoff_community_area dicas

Verifique a versão do Python

 import sys

# Confirm that we're using Python 3
assert sys.version_info.major is 3, 'Oops, not running Python 3. Use Runtime > Change runtime type'
 

instale TFDV

Isso vai puxar em todas as dependências, o que vai levar um minuto. Por favor, ignore os avisos ou erros sobre versões de dependência incompatíveis.

 import tensorflow as tf

print('Installing TensorFlow Data Validation')
!pip install -q tensorflow_data_validation[visualization]
 
Installing TensorFlow Data Validation
ERROR: tensorflow-transform 0.22.0 has requirement tensorflow!=2.0.*,<2.3,>=1.15, but you'll have tensorflow 2.3.0 which is incompatible.
ERROR: tensorflow-serving-api 2.2.0 has requirement tensorflow~=2.2.0, but you'll have tensorflow 2.3.0 which is incompatible.
ERROR: google-cloud-storage 1.30.0 has requirement google-resumable-media<2.0dev,>=0.6.0, but you'll have google-resumable-media 0.5.1 which is incompatible.
WARNING: You are using pip version 20.1.1; however, version 20.2 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.

Você reiniciou o tempo de execução?

Se você estiver usando o Google Colab, a primeira vez que você executar a célula acima, você deve reiniciar o tempo de execução (Runtime> Restart tempo de execução ...). Isto é por causa da maneira que Colab carrega pacotes.

Carregar os arquivos

Vamos baixar o nosso conjunto de dados do Google Cloud Storage.

 import os
import tempfile, urllib, zipfile

# Set up some globals for our file paths
BASE_DIR = tempfile.mkdtemp()
DATA_DIR = os.path.join(BASE_DIR, 'data')
OUTPUT_DIR = os.path.join(BASE_DIR, 'chicago_taxi_output')
TRAIN_DATA = os.path.join(DATA_DIR, 'train', 'data.csv')
EVAL_DATA = os.path.join(DATA_DIR, 'eval', 'data.csv')
SERVING_DATA = os.path.join(DATA_DIR, 'serving', 'data.csv')

# Download the zip file from GCP and unzip it
zip, headers = urllib.request.urlretrieve('https://storage.googleapis.com/artifacts.tfx-oss-public.appspot.com/datasets/chicago_data.zip')
zipfile.ZipFile(zip).extractall(BASE_DIR)
zipfile.ZipFile(zip).close()

print("Here's what we downloaded:")
!ls -R {os.path.join(BASE_DIR, 'data')}
 
Here's what we downloaded:
/tmp/tmpbq0u1j0s/data:
eval  serving  train

/tmp/tmpbq0u1j0s/data/eval:
data.csv

/tmp/tmpbq0u1j0s/data/serving:
data.csv

/tmp/tmpbq0u1j0s/data/train:
data.csv

Verifique a versão

 import tensorflow_data_validation as tfdv
print('TFDV version: {}'.format(tfdv.version.__version__))
 
TFDV version: 0.22.2

Compute e estatísticas Visualize

Primeiro vamos usar tfdv.generate_statistics_from_csv as estatísticas de computação para os nossos dados de treinamento. (Ignorar os avisos mal-humorado)

TFDV pode calcular descritivos estatísticas que fornecem uma visão geral dos dados em termos dos recursos que estão presentes e as formas de suas distribuições de valor.

Internamente, TFDV usa Apache feixe estrutura de processamento de dados em paralelo 's para dimensionar a computação de estatísticas sobre grandes conjuntos de dados. Para aplicações que desejam integrar mais profunda com TFDV (por exemplo, anexar geração de estatísticas, no final de um pipeline de dados-geração), a API também expõe um PTransform feixe para a geração de estatísticas.

 train_stats = tfdv.generate_statistics_from_csv(data_location=TRAIN_DATA)
 
WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.

Warning:apache_beam.io.tfrecordio:Couldn't find python-snappy so the implementation of _TFRecordUtil._masked_crc32c is not as fast as it could be.

Warning:tensorflow:From /home/kbuilder/.local/lib/python3.6/site-packages/tensorflow_data_validation/utils/stats_util.py:229: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`

Warning:tensorflow:From /home/kbuilder/.local/lib/python3.6/site-packages/tensorflow_data_validation/utils/stats_util.py:229: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`

Agora vamos usar tfdv.visualize_statistics , que usa facetas para criar uma visualização sucinta dos nossos dados de treinamento:

  • Observe que recursos numéricos e recursos catagorical são visualizados separadamente, e que os gráficos são exibidos, mostrando as distribuições de cada recurso.
  • Observe que apresenta com falta ou nulos valores exibir uma porcentagem em vermelho como um indicador visual que pode haver problemas com exemplos desses recursos. A percentagem é a percentagem de exemplos que têm falta ou os valores zero para essa função.
  • Note-se que não existem exemplos com valores para pickup_census_tract . Esta é uma oportunidade para redução de dimensionalidade!
  • Tente clicar em "expandir" acima dos gráficos para alterar a exibição
  • Tente pairando sobre bares nas paradas de faixas balde de exibição e contagem
  • Tente alternar entre o registro e escalas lineares, e observe como a escala log revela muito mais detalhes sobre o payment_type característica categórica
  • Tente selecionar "quantiles" do "gráfico para mostrar" no menu, e pairar sobre os marcadores para mostrar as percentagens quantílicas
 tfdv.visualize_statistics(train_stats)
 

Inferir um esquema

Agora vamos usar tfdv.infer_schema para criar um esquema para os nossos dados. Um esquema define restrições para os dados que são relevantes para o ML. Exemplo limitações incluem o tipo de dados de cada recurso, quer se trate de numérico ou categórica, ou a frequência da sua presença nos dados. Para características categóricas o esquema também define o domínio - a lista de valores aceitáveis. Desde escrita de um esquema pode ser uma tarefa tediosa, especialmente para conjuntos de dados com muitos recursos, TFDV fornece um método para gerar uma versão inicial do esquema com base nas estatísticas descritivas.

Obtendo o direito esquema é importante porque o resto da nossa linha de produção estará contando com o esquema que TFDV gera a ser corretas. O esquema também fornece documentação para os dados, e assim é útil quando diferentes desenvolvedores trabalham com os mesmos dados. Vamos uso tfdv.display_schema para exibir o esquema inferido para que possamos analisá-lo.

 schema = tfdv.infer_schema(statistics=train_stats)
tfdv.display_schema(schema=schema)
 
/home/kbuilder/.local/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:138: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Verifique os dados de avaliação para erros

Até agora só estive olhando os dados de treinamento. É importante que os nossos dados de avaliação é consistente com nossos dados de treinamento, inclusive que ele usa o mesmo esquema. Também é importante que os dados de avaliação inclui exemplos de aproximadamente as mesmas faixas de valores para os nossos recursos numéricos como os nossos dados de treinamento, de modo que a nossa cobertura da superfície a perda durante a avaliação é aproximadamente o mesmo que durante o treinamento. O mesmo é verdadeiro para características categóricas. Caso contrário, podemos ter problemas de treinamento que não são identificados durante a avaliação, pois não avaliamos parte de nossa superfície perda.

  • Observe que cada recurso agora inclui estatísticas para ambos os conjuntos de dados de avaliação da formação e.
  • Observe que os gráficos têm agora ambos os conjuntos de dados de treinamento e avaliação sobrepostos, tornando mais fácil para compará-los.
  • Note-se que os gráficos incluem agora um percentagens vista, que podem ser combinados com o registo ou o padrão linear escalas.
  • Observe que a média e mediana para trip_miles são diferentes para o treinamento contra os conjuntos de dados de avaliação. Será que causam problemas?
  • Uau, as max tips é muito diferente para o treinamento contra os conjuntos de dados de avaliação. Será que causam problemas?
  • Clique expandir a Numérico Características gráfico e selecione a escala logarítmica. Reveja as trip_seconds apresentam, e notar a diferença no máx. Will partes avaliação da falta de superfície de perda?
 # Compute stats for evaluation data
eval_stats = tfdv.generate_statistics_from_csv(data_location=EVAL_DATA)

# Compare evaluation data with training data
tfdv.visualize_statistics(lhs_statistics=eval_stats, rhs_statistics=train_stats,
                          lhs_name='EVAL_DATASET', rhs_name='TRAIN_DATASET')
 

Verifique se há anomalias de avaliação

O nosso conjunto de dados de avaliação corresponde ao esquema de nosso conjunto de dados de treinamento? Isto é especialmente importante para características categóricas, onde queremos identificar a faixa de valores aceitáveis.

 # Check eval data for errors by validating the eval data stats using the previously inferred schema.
anomalies = tfdv.validate_statistics(statistics=eval_stats, schema=schema)
tfdv.display_anomalies(anomalies)
 
/home/kbuilder/.local/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:173: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

anomalias de avaliação Fix no esquema

Ops! Parece que temos alguns novos valores para company em nossos dados de avaliação, que nós não temos em nossos dados de treinamento. Temos também um novo valor para payment_type . Estes devem ser considerados anomalias, mas o que nós decidimos fazer com eles depende do nosso conhecimento de domínio dos dados. Se uma anomalia realmente indica um erro de dados, em seguida, os dados subjacentes deve ser corrigido. Caso contrário, podemos simplesmente atualizar o esquema para incluir os valores no conjunto de dados eval.

A menos que mudemos nosso conjunto de dados de avaliação não podemos resolver tudo, mas podemos consertar as coisas no esquema que estamos confortáveis ​​aceitar. Isso inclui relaxante nossa visão do que é eo que não é uma anomalia para características particulares, bem como atualizando nosso esquema para incluir valores em falta para características categóricas. TFDV permitiu-nos descobrir o que temos de corrigir.

Vamos fazer as correções agora, e então rever mais uma vez.

 # Relax the minimum fraction of values that must come from the domain for feature company.
company = tfdv.get_feature(schema, 'company')
company.distribution_constraints.min_domain_mass = 0.9

# Add new value to the domain of feature payment_type.
payment_type_domain = tfdv.get_domain(schema, 'payment_type')
payment_type_domain.value.append('Prcard')

# Validate eval stats after updating the schema 
updated_anomalies = tfdv.validate_statistics(eval_stats, schema)
tfdv.display_anomalies(updated_anomalies)
 

Ei, olha isso! Verificou-se que os dados de treinamento e avaliação agora são consistentes! Graças TFDV;)

esquema Ambientes

Também dividir fora de um conjunto de dados 'servir' para este exemplo, por isso deve verificar isso também. Por padrão, todos os conjuntos de dados em um gasoduto deve utilizar o mesmo esquema, mas muitas vezes há exceções. Por exemplo, no aprendizado supervisionado precisamos incluir rótulos em nosso conjunto de dados, mas quando servimos o modelo de inferência os rótulos não serão incluídos. Em alguns casos, a introdução de variações de esquema leves é necessário.

Os ambientes podem ser usados para expressar tais requisitos. Em particular, recursos do esquema pode ser associado a um conjunto de ambientes que utilizam default_environment , in_environment e not_in_environment .

Por exemplo, neste conjunto de dados do tips recurso está incluído como rótulo para treinamento, mas está faltando nos dados que servem. Sem ambiente especificado, ele vai aparecer como uma anomalia.

 serving_stats = tfdv.generate_statistics_from_csv(SERVING_DATA)
serving_anomalies = tfdv.validate_statistics(serving_stats, schema)

tfdv.display_anomalies(serving_anomalies)
 
/home/kbuilder/.local/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:173: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Nós vamos lidar com as tips abaixo recurso. Temos também um valor INT em nossos segundos viagem, onde o nosso esquema esperados um float. Ao tornar-nos conscientes dessa diferença, TFDV ajuda inconsistências desvendar na forma como os dados são gerados para treinar e servir. É muito fácil não ter conhecimento de problemas como que até sofre desempenho do modelo, às vezes catastroficamente. Ele pode ou não ser um problema significativo, mas em qualquer caso, este deve ser motivo de uma investigação mais aprofundada.

Neste caso, podemos seguramente converter valores INT para bóias, por isso queremos dizer TFDV para usar nosso esquema para inferir o tipo. Vamos fazer isso agora.

 options = tfdv.StatsOptions(schema=schema, infer_type_from_schema=True)
serving_stats = tfdv.generate_statistics_from_csv(SERVING_DATA, stats_options=options)
serving_anomalies = tfdv.validate_statistics(serving_stats, schema)

tfdv.display_anomalies(serving_anomalies)
 
/home/kbuilder/.local/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:173: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Agora só temos o tips recurso (que é o nosso rótulo) aparecendo como uma anomalia ( 'Coluna caiu'). Claro que não esperamos ter rótulos em nossos dados que servem, então vamos dizer TFDV ignorar isso.

 # All features are by default in both TRAINING and SERVING environments.
schema.default_environment.append('TRAINING')
schema.default_environment.append('SERVING')

# Specify that 'tips' feature is not in SERVING environment.
tfdv.get_feature(schema, 'tips').not_in_environment.append('SERVING')

serving_anomalies_with_env = tfdv.validate_statistics(
    serving_stats, schema, environment='SERVING')

tfdv.display_anomalies(serving_anomalies_with_env)
 

Verificar a existência de desvio e inclinação

Além de verificar se um conjunto de dados está em conformidade com as expectativas definidas no esquema, TFDV também fornece funcionalidades para detectar desvio e inclinação. TFDV realiza essa verificação, comparando as estatísticas dos diferentes conjuntos de dados com base nos deriva comparadores / inclinação especificados no esquema.

Deriva

detecção deriva é suportado por características e categóricas entre vãos consecutivos de dados (isto é, entre a extensão e extensão N N + 1), tal como entre os diferentes dias de dados de treino. Expressamos deriva em termos de distância L-infinito , e você pode definir a distância limite para que você receba avisos quando o desvio é maior do que é aceitável. Definir a distância correcta é normalmente um processo iterativo que exige conhecimento do domínio e experimentação.

enviesado

TFDV pode detectar três tipos diferentes de inclinação em seus dados - esquema de inclinação, apresentam inclinação, e distribuição de inclinação.

esquema de inclinação

Esquema de inclinação ocorre quando os dados de treinamento e servindo não se conformam com o mesmo esquema. Treinamento e servindo de dados são esperados para aderir ao mesmo esquema. Quaisquer desvios esperados entre os dois (como o recurso de rótulo estar presente apenas nos dados de treinamento, mas não no serviço) deve ser especificado através do campo ambientes no esquema.

recurso de inclinação

Recurso de inclinação ocorre quando os valores de recursos que um modelo de trens em são diferentes dos valores de recursos que ele vê na hora de servir. Por exemplo, isso pode acontecer quando:

  • Uma fonte de dados que fornece alguns valores recurso é modificado entre a formação eo tempo servindo
  • Há uma lógica diferente para a geração de recursos entre a formação e servir. Por exemplo, se você aplicar alguma transformação apenas em um dos dois caminhos de código.

distribuição de inclinação

Distribuição distorção ocorre quando a distribuição do conjunto de dados de treinamento é significativamente diferente da distribuição do conjunto de dados de servir. Uma das causas principais para a inclinação de distribuição está usando o código diferente ou fontes de dados diferentes para gerar o conjunto de dados de treinamento. Outra razão é um mecanismo de amostragem defeituoso que escolhe uma sub-amostra não representativa dos dados que servem para treinar.

 # Add skew comparator for 'payment_type' feature.
payment_type = tfdv.get_feature(schema, 'payment_type')
payment_type.skew_comparator.infinity_norm.threshold = 0.01

# Add drift comparator for 'company' feature.
company=tfdv.get_feature(schema, 'company')
company.drift_comparator.infinity_norm.threshold = 0.001

skew_anomalies = tfdv.validate_statistics(train_stats, schema,
                                          previous_statistics=eval_stats,
                                          serving_statistics=serving_stats)

tfdv.display_anomalies(skew_anomalies)
 
/home/kbuilder/.local/lib/python3.6/site-packages/tensorflow_data_validation/utils/display_util.py:173: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.
  pd.set_option('max_colwidth', -1)

Neste exemplo nós fazemos ver alguns deriva, mas é bem abaixo do limite que nós definimos.

Congelar o esquema

Agora que o esquema foi revisto e curadoria, vamos armazená-lo em um arquivo para refletir seu estado "congelado".

 from tensorflow.python.lib.io import file_io
from google.protobuf import text_format

file_io.recursive_create_dir(OUTPUT_DIR)
schema_file = os.path.join(OUTPUT_DIR, 'schema.pbtxt')
tfdv.write_schema_text(schema, schema_file)

!cat {schema_file}
 
feature {
  name: "pickup_community_area"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "fare"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "trip_start_month"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "trip_start_hour"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "trip_start_day"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "trip_start_timestamp"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "pickup_latitude"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "pickup_longitude"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "dropoff_latitude"
  value_count {
    min: 1
    max: 1
  }
  type: FLOAT
  presence {
    min_count: 1
  }
}
feature {
  name: "dropoff_longitude"
  value_count {
    min: 1
    max: 1
  }
  type: FLOAT
  presence {
    min_count: 1
  }
}
feature {
  name: "trip_miles"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "pickup_census_tract"
  type: BYTES
  presence {
    min_count: 0
  }
}
feature {
  name: "dropoff_census_tract"
  value_count {
    min: 1
    max: 1
  }
  type: INT
  presence {
    min_count: 1
  }
}
feature {
  name: "payment_type"
  type: BYTES
  domain: "payment_type"
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  skew_comparator {
    infinity_norm {
      threshold: 0.01
    }
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "company"
  value_count {
    min: 1
    max: 1
  }
  type: BYTES
  domain: "company"
  presence {
    min_count: 1
  }
  distribution_constraints {
    min_domain_mass: 0.9
  }
  drift_comparator {
    infinity_norm {
      threshold: 0.001
    }
  }
}
feature {
  name: "trip_seconds"
  type: INT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  shape {
    dim {
      size: 1
    }
  }
}
feature {
  name: "dropoff_community_area"
  value_count {
    min: 1
    max: 1
  }
  type: INT
  presence {
    min_count: 1
  }
}
feature {
  name: "tips"
  type: FLOAT
  presence {
    min_fraction: 1.0
    min_count: 1
  }
  not_in_environment: "SERVING"
  shape {
    dim {
      size: 1
    }
  }
}
string_domain {
  name: "payment_type"
  value: "Cash"
  value: "Credit Card"
  value: "Dispute"
  value: "No Charge"
  value: "Pcard"
  value: "Unknown"
  value: "Prcard"
}
string_domain {
  name: "company"
  value: "0118 - 42111 Godfrey S.Awir"
  value: "0694 - 59280 Chinesco Trans Inc"
  value: "1085 - 72312 N and W Cab Co"
  value: "2733 - 74600 Benny Jona"
  value: "2809 - 95474 C & D Cab Co Inc."
  value: "3011 - 66308 JBL Cab Inc."
  value: "3152 - 97284 Crystal Abernathy"
  value: "3201 - C&D Cab Co Inc"
  value: "3201 - CID Cab Co Inc"
  value: "3253 - 91138 Gaither Cab Co."
  value: "3385 - 23210 Eman Cab"
  value: "3623 - 72222 Arrington Enterprises"
  value: "3897 - Ilie Malec"
  value: "4053 - Adwar H. Nikola"
  value: "4197 - 41842 Royal Star"
  value: "4615 - 83503 Tyrone Henderson"
  value: "4615 - Tyrone Henderson"
  value: "4623 - Jay Kim"
  value: "5006 - 39261 Salifu Bawa"
  value: "5006 - Salifu Bawa"
  value: "5074 - 54002 Ahzmi Inc"
  value: "5074 - Ahzmi Inc"
  value: "5129 - 87128"
  value: "5129 - 98755 Mengisti Taxi"
  value: "5129 - Mengisti Taxi"
  value: "5724 - KYVI Cab Inc"
  value: "585 - Valley Cab Co"
  value: "5864 - 73614 Thomas Owusu"
  value: "5864 - Thomas Owusu"
  value: "5874 - 73628 Sergey Cab Corp."
  value: "5997 - 65283 AW Services Inc."
  value: "5997 - AW Services Inc."
  value: "6488 - 83287 Zuha Taxi"
  value: "6743 - Luhak Corp"
  value: "Blue Ribbon Taxi Association Inc."
  value: "C & D Cab Co Inc"
  value: "Chicago Elite Cab Corp."
  value: "Chicago Elite Cab Corp. (Chicago Carriag"
  value: "Chicago Medallion Leasing INC"
  value: "Chicago Medallion Management"
  value: "Choice Taxi Association"
  value: "Dispatch Taxi Affiliation"
  value: "KOAM Taxi Association"
  value: "Northwest Management LLC"
  value: "Taxi Affiliation Services"
  value: "Top Cab Affiliation"
}
default_environment: "TRAINING"
default_environment: "SERVING"

Quando usar TFDV

É fácil pensar em TFDV como única aplicação para o início do seu pipeline de formação, como fizemos aqui, mas na verdade ele tem muitos usos. Aqui está um pouco mais:

  • Validação de novos dados para a inferência para se certificar de que não temos de repente começou a receber recursos ruins
  • Validação de novos dados para a inferência para se certificar de que o nosso modelo tem treinado em que parte da superfície da decisão
  • Validar nossos dados depois que nós transformamos e engenharia recurso feito (provavelmente usando TensorFlow Transform ) para se certificar de que não fizemos algo errado