def config_spec(self) -> types.Spec: return { INTERPOLATION_KEY: types.Scalar(min_val=5, max_val=200, default=IG_STEPS, step=1), MAX_DIST_KEY: types.Scalar(min_val=0.0, max_val=1.0, default=0.1, step=0.02) }
def spec(self): return { 'span1_embs': lit_types.Embeddings(), 'span2_embs': lit_types.Embeddings(), 'label': lit_types.Scalar(), 'src_idx': lit_types.Scalar(), 'edge_idx': lit_types.Scalar(), }
def input_spec(self): return { 'body_mass_g': lit_types.Scalar(), 'culmen_depth_mm': lit_types.Scalar(), 'culmen_length_mm': lit_types.Scalar(), 'flipper_length_mm': lit_types.Scalar(), 'island': lit_types.CategoryLabel(vocab=VOCABS['island']), 'sex': lit_types.CategoryLabel(vocab=VOCABS['sex']), }
def set_up_pandas_dataframe_and_columns(): dataframe = pd.DataFrame.from_dict({ "feature_1": [1.0], "feature_2": [3.0], "label": [1.0] }) columns = collections.OrderedDict([ ("feature_1", lit_types.Scalar()), ("feature_2", lit_types.Scalar()), ("label", lit_types.RegressionScore()), ]) yield dataframe, columns
def spec(self): return { "text": lit_types.TextSegment(), "tokens": lit_types.Tokens(parent="text"), "coref": lit_types.EdgeLabels(align="tokens"), # Metadata fields for filtering and analysis. "occupation": lit_types.CategoryLabel(), "participant": lit_types.CategoryLabel(), "answer": lit_types.CategoryLabel(vocab=ANSWER_VOCAB), "someone": lit_types.CategoryLabel(vocab=["True", "False"]), "pronouns": lit_types.CategoryLabel(vocab=list(PRONOUNS_BY_GENDER.values())), "pronoun_type": lit_types.CategoryLabel(vocab=["NOM", "POSS", "ACC"]), "gender": lit_types.CategoryLabel(vocab=[g.name for g in Gender]), "pf_bls": lit_types.Scalar(), }
def test_find_spec_keys(self): spec = { "score": types.RegressionScore(), "scalar_foo": types.Scalar(), "text": types.TextSegment(), "emb_0": types.Embeddings(), "emb_1": types.Embeddings(), "tokens": types.Tokens(), "generated_text": types.GeneratedText(), } self.assertEqual(["score"], utils.find_spec_keys(spec, types.RegressionScore)) self.assertEqual(["text", "tokens", "generated_text"], utils.find_spec_keys(spec, (types.TextSegment, types.Tokens))) self.assertEqual(["emb_0", "emb_1"], utils.find_spec_keys(spec, types.Embeddings)) self.assertEqual([], utils.find_spec_keys(spec, types.AttentionHeads)) # Check subclasses self.assertEqual( list(spec.keys()), utils.find_spec_keys(spec, types.LitType)) self.assertEqual(["text", "generated_text"], utils.find_spec_keys(spec, types.TextSegment)) self.assertEqual(["score", "scalar_foo"], utils.find_spec_keys(spec, types.Scalar))
def config_spec(self) -> types.Spec: return { SALIENCE_MAPPER_KEY: types.CategoryLabel(required=True, vocab=list(self.salience_mappers.keys())), N_CLUSTERS_KEY: types.Scalar(min_val=2, max_val=100, default=2, step=1), }
def input_spec(self) -> lit_types.Spec: return { 'size': lit_types.CategoryLabel(vocab=['small', 'medium', 'large']), 'weight': lit_types.Scalar(), 'legs': lit_types.Boolean(), 'description': lit_types.String(), }
def config_spec(self) -> types.Spec: return { CLASS_KEY: types.TextSegment(default=''), NORMALIZATION_KEY: types.Boolean(default=True), INTERPOLATION_KEY: types.Scalar(min_val=5, max_val=100, default=30, step=1) }
def config_spec(self) -> lit_types.Spec: return { NUM_EXAMPLES_KEY: lit_types.Scalar(min_val=1, max_val=20, default=NUM_EXAMPLES_DEFAULT, step=1), MAX_FLIPS_KEY: lit_types.Scalar(min_val=1, max_val=10, default=MAX_FLIPS_DEFAULT, step=1), PREDICTION_KEY: lit_types.FieldMatcher( spec='output', types=['MulticlassPreds', 'RegressionScore']), REGRESSION_THRESH_KEY: lit_types.TextSegment(default=str(REGRESSION_THRESH_DEFAULT)), }
def output_spec(self) -> lit_types.Spec: return { "src_tokens": lit_types.Tokens(parent="src_text"), "trg_text": lit_types.GeneratedText(parent="ref_text"), "trg_tokens": lit_types.Tokens(parent="trg_text"), "attention": lit_types.AttentionHeads(align_in="src_tokens", align_out="trg_tokens"), "pred_tokens": lit_types.TokenTopKPreds(align="trg_tokens", parent="trg_text"), "encoder_final_embedding": lit_types.Embeddings(), "ter": lit_types.Scalar(), "chrf3": lit_types.Scalar(), }
def input_spec(self): return { 'text': lit_types.TextSegment(), 'tokens': lit_types.Tokens(parent='text'), 'coref': lit_types.EdgeLabels(align='tokens'), # Index of predicted (single) edge for Winogender 'answer': lit_types.CategoryLabel(vocab=winogender.ANSWER_VOCAB, required=False), # TODO(b/172975096): allow plotting of scalars from input data, # so we don't need to add this to the predictions. 'pf_bls': lit_types.Scalar(required=False), }
def output_spec(self): # TODO(lit-dev): also return the embeddings for each span on datasets # with a fixed number of targets; for Winogender this would be # {occupation, other participant, pronoun} return { 'tokens': lit_types.Tokens(parent='text'), 'coref': lit_types.EdgeLabels(align='tokens'), 'pred_answer': lit_types.MulticlassPreds(vocab=winogender.ANSWER_VOCAB, parent='answer'), # TODO(b/172975096): allow plotting of scalars from input data, # so we don't need to add this to the predictions. 'pf_bls': lit_types.Scalar(), }
def testTfxModel(self): input_spec = {'input_0': lit_types.Scalar()} output_spec = { 'output_0': lit_types.MulticlassPreds(vocab=['0', '1'], parent='input_0') } config = tfx_model.TFXModelConfig(self._path, input_spec, output_spec) lit_model = tfx_model.TFXModel(config) result = list(lit_model.predict([{'input_0': 0.5}])) self.assertLen(result, 1) result = result[0] self.assertListEqual(list(result.keys()), ['output_0']) self.assertLen(result['output_0'], 2) self.assertIsInstance(result['output_0'][0], float) self.assertIsInstance(result['output_0'][1], float) self.assertDictEqual(lit_model.input_spec(), input_spec) self.assertDictEqual(lit_model.output_spec(), output_spec)
def output_spec(self): spec = { "input_tokens": lit_types.Tokens(parent="input_text"), "generation": lit_types.GeneratedText(parent="target_text"), "encoder_final_embedding": lit_types.Embeddings(), # If target text is given, the following will also be populated. "target_tokens": lit_types.Tokens(parent="target_text"), "pred_tokens": lit_types.TokenTopKPreds(align="target_tokens"), "rougeL": lit_types.Scalar(), } if self.config.output_attention: # Add attention for each layer. for i in range(self.num_layers): spec[f"encoder_layer_{i:d}_attention"] = lit_types.AttentionHeads( align=("input_tokens", "input_tokens")) spec[f"decoder_layer_{i:d}_attention"] = lit_types.AttentionHeads( align=("target_tokens", "target_tokens")) return spec
def test_remap(self): """Test remap method.""" spec = { "score": types.Scalar(), "text": types.TextSegment(), } datapoints = [ { "score": 0, "text": "a" }, { "score": 0, "text": "b" }, ] dset = lit_dataset.Dataset(spec, datapoints) remap_dict = {"score": "val", "nothing": "nada"} remapped_dset = dset.remap(remap_dict) self.assertIn("val", remapped_dset.spec()) self.assertNotIn("score", remapped_dset.spec()) self.assertEqual({"val": 0, "text": "a"}, remapped_dset.examples[0])
def input_spec(self): return {'val': lit_types.Scalar()}
def input_spec(self): return { 'span1_embs': lit_types.Embeddings(), 'span2_embs': lit_types.Embeddings(), 'label': lit_types.Scalar(required=False), # in range [0,1] }
def feature_types(): yield collections.OrderedDict([("feature_1", lit_types.Scalar()), ("feature_2", lit_types.Scalar())])
def input_spec(self): return {'num': lit_types.Scalar(), 'cats': lit_types.CategoryLabel(vocab=['One', 'None'])}
def output_spec(self): spec = lit_types.remap_spec(self.model.output_spec(), self.FIELD_RENAMES) spec["rougeL"] = lit_types.Scalar() return spec
def config_spec(self) -> types.Spec: return { INTERPOLATION_KEY: types.Scalar(min_val=5, max_val=200, default=IG_STEPS, step=1) }
def spec(self) -> lit_types.Spec: """Dataset spec, which should match the model"s input_spec().""" return { "Sentence": lit_types.TextSegment(), "Token Index to Explain": lit_types.Scalar() }
def input_spec(self) -> lit_types.Spec: return { "Sentence": lit_types.TextSegment(), "Token Index to Explain": lit_types.Scalar() }
def input_spec(self) -> lit_types.Spec: return { 'x_1': lit_types.Scalar(), 'x_2': lit_types.Scalar(), }