python_code
stringlengths 0
91.3k
|
|---|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utilities for generating zero-shot prompts."""
import re
import string
from typing import Sequence
from absl import logging
from big_vision.datasets.imagenet import class_names as imagenet_class_names
from big_vision.evaluators.proj.image_text import prompt_engineering_constants
import tensorflow_datasets as tfds
_CLASS_NAMES = { # For each dataset, maps from a source to its class names.
"imagenet2012": {
"clip": imagenet_class_names.CLIP_IMAGENET_CLASS_NAMES,
},
"grand-vision:imagenet2012": {
"clip": imagenet_class_names.CLIP_IMAGENET_CLASS_NAMES,
},
"imagenet_a": {
"clip": [
imagenet_class_names.CLIP_IMAGENET_CLASS_NAMES[i]
for i in imagenet_class_names.IMAGENET_A_LABELSET
]
},
"imagenet_r": {
"clip": [
imagenet_class_names.CLIP_IMAGENET_CLASS_NAMES[i]
for i in imagenet_class_names.IMAGENET_R_LABELSET
]
},
"imagenet_v2": {
"clip": imagenet_class_names.CLIP_IMAGENET_CLASS_NAMES,
},
}
_PROMPT_TEMPLATES = {
"class_name_only": ["{}"],
"clip_paper": prompt_engineering_constants.CLIP_PAPER_PROMPT_TEMPLATES,
"clip_best": prompt_engineering_constants.CLIP_BEST_PROMPT_TEMPLATES,
}
def get_class_names(*, dataset_name, source="dataset_info", canonicalize=True):
"""Returns class name for `dataset_name` from `source`."""
if isinstance(source, str):
if source.startswith("dataset_info:"):
name = source[len("dataset_info:"):]
class_names = tfds.builder(dataset_name).info.features[name].names
else:
class_names = _CLASS_NAMES[dataset_name][source]
else:
assert isinstance(source, Sequence) and all(
map(lambda s: isinstance(s, str), source)), source
class_names = source
if canonicalize:
class_names = [
_canonicalize(name, keep_punctuation_exact_string=",")
for name in class_names
]
logging.info("Using %d class_names: %s", len(class_names), class_names)
return class_names
def get_prompt_templates(prompt_templates_name,
*,
canonicalize=True):
"""Returns prompt templates."""
prompts_templates = _PROMPT_TEMPLATES[prompt_templates_name]
if canonicalize:
prompts_templates = [
_canonicalize(name, keep_punctuation_exact_string="{}")
for name in prompts_templates
]
logging.info("Using %d prompts_templates: %s", len(prompts_templates),
prompts_templates)
return prompts_templates
def _canonicalize(text, *, keep_punctuation_exact_string=None):
"""Returns canonicalized `text` (lowercase and puncuation removed).
Args:
text: string to be canonicalized.
keep_punctuation_exact_string: If provided, then this exact string kept.
For example providing '{}' will keep any occurrences of '{}' (but will
still remove '{' and '}' that appear separately).
"""
text = text.replace("_", " ")
if keep_punctuation_exact_string:
text = keep_punctuation_exact_string.join(
part.translate(str.maketrans("", "", string.punctuation))
for part in text.split(keep_punctuation_exact_string))
else:
text = text.translate(str.maketrans("", "", string.punctuation))
text = text.lower()
text = re.sub(r"\s+", " ", text)
return text.strip()
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for retrieval."""
from unittest import mock
from big_vision.evaluators.proj.image_text import retrieval
from big_vision.pp import ops_general # pylint: disable=unused-import
from big_vision.pp import ops_image # pylint: disable=unused-import
from big_vision.pp import registry
import chex
import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
import tensorflow as tf
import tensorflow_datasets as tfds
def _get_test_texts2labels():
def pp(features):
features["labels"] = tf.strings.to_number(features["texts"])
return features
return pp
def _get_copy_from(**key_map):
def copy_from(d):
d = dict(d)
for k1, k2 in key_map.items():
d[k1] = d[k2]
return d
return copy_from
class _Model(nn.Module):
@nn.compact
def __call__(self, image, texts):
self.param("x", lambda _: 0.)
def z(x):
if x is not None:
batch_size = len(x)
# Note that the returned vector is most similar with other vectors
# generated from the same underlying `x[:]`.
x = jnp.concatenate([100 * jnp.ones([batch_size, 1]), x[:, None]],
axis=1)
return x / jnp.linalg.norm(x, axis=1)[:, None]
return z(image), z(texts), None
def setUpModule():
chex.set_n_cpu_devices(8)
class RetrievalTest(tf.test.TestCase):
def test_prepare_datasets(self):
def generator():
yield {
"image": tf.ones([5, 5, 3], tf.float32),
"captions": {
"text": tf.constant(["11", "12"])
}
}
yield {
"image": tf.ones([4, 4, 3], tf.float32),
"captions": {
"text": tf.constant(["21", "22", "23"])
}
}
ds = tf.data.Dataset.from_generator(
generator,
output_signature={
"image": tf.TensorSpec(shape=[None, None, 3], dtype=tf.float32),
"captions": {
"text": tf.TensorSpec(shape=[None], dtype=tf.string),
},
})
with registry.temporary_ops(test_texts2labels=_get_test_texts2labels):
ds_img, ds_txt = retrieval.prepare_datasets(
ds,
pp_img="resize(2)",
pp_txt="test_texts2labels()",
txt_name=("captions", "text"),
)
it_img = iter(ds_img)
it_txt = iter(ds_txt)
batch = next(it_img)
self.assertAllEqual(batch["id"], 0)
self.assertAllEqual(batch["image"], tf.ones([2, 2, 3]))
batch = next(it_img)
self.assertAllEqual(batch["id"], 1)
self.assertAllEqual(batch["image"], tf.ones([2, 2, 3]))
batch = next(it_txt)
self.assertAllEqual(batch["id"], 0)
self.assertAllEqual(batch["caption_i"], 0)
self.assertAllEqual(batch["labels"], 11.0)
batch = next(it_txt)
self.assertAllEqual(batch["id"], 0)
self.assertAllEqual(batch["caption_i"], 1)
self.assertAllEqual(batch["labels"], 12.0)
batch = next(it_txt)
self.assertAllEqual(batch["id"], 1)
self.assertAllEqual(batch["caption_i"], 0)
self.assertAllEqual(batch["labels"], 21.0)
batch = next(it_txt)
self.assertAllEqual(batch["id"], 1)
self.assertAllEqual(batch["caption_i"], 1)
self.assertAllEqual(batch["labels"], 22.0)
batch = next(it_txt)
self.assertAllEqual(batch["id"], 1)
self.assertAllEqual(batch["caption_i"], 2)
self.assertAllEqual(batch["labels"], 23.0)
def test_evaluate(self):
per_device_batch_size = 2
batch_size = per_device_batch_size * jax.device_count()
num_examples = 1 * batch_size + 1
splits = {
"test":
tfds.core.SplitInfo(
name="test", shard_lengths=[num_examples], num_bytes=0)
}
model = _Model()
params = model.init(jax.random.PRNGKey(0), None, None)["params"]
with tfds.testing.mock_data(num_examples=num_examples):
info_mock = mock.Mock()
info_mock.splits = splits
with mock.patch.object(retrieval, "_get_dataset_info",
lambda _: info_mock):
with registry.temporary_ops(copy_from=_get_copy_from):
evaluator = retrieval.Evaluator(
lambda p, i, t: model.apply({"params": p}, i, t),
dataset="coco_captions",
batch_size=batch_size,
txt_name=("captions", "text"),
pp_img="copy_from(image='id')",
pp_txt="copy_from(labels='id')",
)
results = evaluator.evaluate(flax.jax_utils.replicate(params))
# Assert all examples were processed.
self.assertLen(results["images"]["embeddings"], num_examples)
self.assertLen(results["images"]["id"], num_examples)
# Assert no padding was processed (expects exactly one (=first) image.id=0
self.assertEqual((results["images"]["id"] == 0).sum(), 1)
# Expect perfect ITR with above _Model()...
self.assertEqual(results["img2txt"]["Recall@1"], 1.0)
self.assertEqual(results["txt2img"]["Recall@5"], 1.0)
if __name__ == "__main__":
tf.test.main()
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for discriminative_classifier."""
from unittest import mock
from big_vision.evaluators.proj.image_text import discriminative_classifier
from big_vision.pp import ops_general # pylint: disable=unused-import
from big_vision.pp import ops_image # pylint: disable=unused-import
from big_vision.pp.registry import Registry
import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds
@Registry.register("preprocess_ops.test_texts2labels")
def _get_test_texts2labels():
def pp(features):
features["labels"] = tf.strings.to_number(features["texts"])
return features
return pp
@Registry.register("preprocess_ops.copy_from")
def _get_copy_from(**key_map):
def copy_from(d):
d = dict(d)
for k1, k2 in key_map.items():
d[k1] = d[k2]
return d
return copy_from
class _Model(nn.Module):
@nn.compact
def __call__(self, image, texts):
self.param("x", lambda _: 0.)
def z(x):
if x is not None:
# Note that the returned vector is most similar with other vectors
# generated from the same underlying `x[:]`.
return jnp.stack([jnp.cos(x / 10.), jnp.sin(x / 10.)]).T
if texts is not None:
texts %= 5 # For testing `filter_fn` below.
return z(image), z(texts), None
class DiscriminativeClassifierTest(tf.test.TestCase):
def test_prepare_datasets(self):
def generator():
yield {
"image": tf.ones([5, 5, 3], tf.float32),
"label": 1,
}
yield {
"image": tf.ones([4, 4, 3], tf.float32),
"label": 2,
}
ds = tf.data.Dataset.from_generator(
generator,
output_signature={
"image": tf.TensorSpec(shape=[None, None, 3], dtype=tf.float32),
"label": tf.TensorSpec(shape=[], dtype=tf.int64),
})
class_names = [
"class1,class1a",
"class2",
]
prompt_templates = [
"test {}",
"test {} test",
]
ds_img, ds_txt = discriminative_classifier.prepare_datasets(
ds,
class_names,
prompt_templates=prompt_templates,
pp_img="resize(2)",
pp_txt="copy_from(labels='texts')",
)
it_img = iter(ds_img)
batch = next(it_img)
self.assertAllEqual(1, batch["label"])
self.assertAllEqual(tf.ones([2, 2, 3]), batch["image"])
batch = next(it_img)
self.assertAllEqual(2, batch["label"])
self.assertAllEqual(tf.ones([2, 2, 3]), batch["image"])
it_txt = iter(ds_txt)
batch = next(it_txt)
self.assertAllEqual(0, batch["label"])
self.assertAllEqual("test class1", batch["labels"])
batch = next(it_txt)
self.assertAllEqual(0, batch["label"])
self.assertAllEqual("test class1 test", batch["labels"])
batch = next(it_txt)
self.assertAllEqual(0, batch["label"])
self.assertAllEqual("test class1a", batch["labels"])
batch = next(it_txt)
self.assertAllEqual(0, batch["label"])
self.assertAllEqual("test class1a test", batch["labels"])
batch = next(it_txt)
self.assertAllEqual(1, batch["label"])
self.assertAllEqual("test class2", batch["labels"])
batch = next(it_txt)
self.assertAllEqual(1, batch["label"])
self.assertAllEqual("test class2 test", batch["labels"])
def test_average_embeddings(self):
self.assertAllEqual(jnp.array([
[2.], [4.], [8.],
]), discriminative_classifier._average_embeddings(
embeddings=jnp.array([
1., 3., 3., 1., # label1
8., 0., # label2
32., 0., 0., 0., # label3
])[..., None],
labels=jnp.array([
0, 0, # label1
0, 0, # label1 (alias)
1, 1, # label2
2, 2, # label3
2, 2, # label3 (alias)
], jnp.int32),
num_classes=3, normalize=False))
self.assertAllEqual(
jnp.array([
[2**-.5, 2**-.5],
]),
discriminative_classifier._average_embeddings(
embeddings=jnp.array([[2., 2.]]),
labels=jnp.array([0], jnp.int32),
num_classes=1,
normalize=True))
@mock.patch("big_vision.evaluators.proj."
"image_text.prompt_engineering.get_class_names")
@mock.patch("big_vision.evaluators.proj."
"image_text.prompt_engineering.get_prompt_templates")
@mock.patch("big_vision.evaluators.proj."
"image_text.discriminative_classifier._get_dataset_info")
def test_evaluate(self, get_dataset_info_mock, get_prompt_templates_mock,
get_class_names_mock):
per_device_batch_size = 10 # Make sure we have some unfiltered examples.
global_batch_size = per_device_batch_size * jax.device_count()
per_host_num_examples = int(
np.ceil(global_batch_size / jax.process_count()))
splits = {
"test":
tfds.core.SplitInfo(
name="test", shard_lengths=[per_host_num_examples], num_bytes=0)
}
model = _Model()
params = model.init(jax.random.PRNGKey(0), None, None)["params"]
prompt_templates = [
"test prompt 1 {}",
"test prompt 2 {}",
]
class_names = [
f"test_class_{i}" for i in range(10)
]
get_prompt_templates_mock.return_value = prompt_templates
get_class_names_mock.return_value = class_names
get_dataset_info_mock.return_value.splits = splits
def filter_fn(features):
return features["label"] < 5 # matches `texts %= 5` above
dataset_name = "cifar10_test"
with tfds.testing.mock_data(num_examples=per_host_num_examples):
evaluator = discriminative_classifier.Evaluator(
lambda p, i, t: model.apply({"params": p}, i, t),
dataset_names=[dataset_name],
prompt_templates="test_prompts",
batch_size=global_batch_size,
pp_img="copy_from(image='label')",
pp_txt="copy_from(labels='label')",
dataset_overrides={
dataset_name: {
"dataset_name": "cifar10",
"class_names": "test_classes",
"filter_fn": filter_fn,
}
},
first_class_name_only=True,
)
results = evaluator.evaluate(
flax.jax_utils.replicate(params),
dataset_name,
return_embeddings=True)
metrics = dict(evaluator.run(flax.jax_utils.replicate(params)))
# Assert all examples were processed.
self.assertLen(results["texts"]["embedding"],
len(class_names) * len(prompt_templates))
self.assertLen(results["texts"]["average_embedding"], len(class_names))
self.assertAllEqual(
sorted(results["texts"]["label"]),
[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9])
# Note that above model makes perfect predictions by design.
self.assertEqual(1.0, results["accuracy"])
self.assertEqual(1.0, metrics[f"{dataset_name}_accuracy"])
if __name__ == "__main__":
tf.test.main()
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for training MLP-Mixer-B/16 model on ILSVRC-2012 ("ImageNet-1k").
Achieves 76.3% top-1 accuracy on the test split in 2h11m on TPU v3-128
with 300 epochs. A shorter 60 epochs run is expected to get to 70.5% in 27m.
big_vision.train \
--config big_vision/configs/mlp_mixer_i1k.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
"""
from big_vision.configs.common_fewshot import get_fewshot_lsr
import ml_collections as mlc
def get_config(mode=None):
"""Config for training Mixer on i1k."""
config = mlc.ConfigDict()
config.seed = 0
config.total_epochs = 300
config.num_classes = 1000
config.loss = 'sigmoid_xent'
config.init_head_bias = -6.9
config.input = dict()
config.input.data = dict(
name='imagenet2012',
split='train[:99%]',
)
config.input.batch_size = 4096
config.input.cache_raw = True # Needs up to 120GB of RAM!
config.input.shuffle_buffer_size = 250_000
config.input.pp = (
'decode_jpeg_and_inception_crop(224)'
'|flip_lr'
'|randaug(2,15)'
'|value_range(-1, 1)'
'|onehot(1000, key="label", key_result="labels")'
'|keep("image", "labels")'
)
pp_eval = (
'decode'
'|resize_small(256)|central_crop(224)'
'|value_range(-1, 1)'
'|onehot(1000, key="{lbl}", key_result="labels")'
'|keep("image", "labels")'
)
config.log_training_steps = 50
config.ckpt_steps = 1000
config.prefetch_to_device = 2
# Model section
config.model_name = 'mlp_mixer'
config.model = dict()
config.model.variant = 'B/16'
config.model.stoch_depth = 0.1
config.mixup = dict(fold_in=None, p=0.5)
# Optimizer section
config.optax_name = 'scale_by_adam'
config.grad_clip_norm = 1.
config.lr = 0.001
config.wd = 1e-4
config.schedule = dict(
decay_type='linear',
warmup_steps=10_000,
linear_end=1e-5,
)
# Eval section
def get_eval(split, dataset='imagenet2012'):
return dict(
type='classification',
data=dict(name=dataset, split=split),
pp_fn=pp_eval.format(lbl='label'),
loss_name=config.loss,
log_steps=2500, # Very fast O(seconds) so it's fine to run it often.
cache_final=mode != 'gpu8',
)
config.evals = {}
config.evals.train = get_eval('train[:2%]')
config.evals.minival = get_eval('train[99%:]')
config.evals.val = get_eval('validation')
config.evals.v2 = get_eval('test', dataset='imagenet_v2')
config.evals.real = get_eval('validation', dataset='imagenet2012_real')
config.evals.real.pp_fn = pp_eval.format(lbl='real_label')
config.fewshot = get_fewshot_lsr()
if mode == 'gpu8':
config.total_epochs = 60
config.input.batch_size = 512
config.input.cache_raw = False
if mode == 'regression_test':
config.total_epochs = 60
return config
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pytype: disable=not-writable,attribute-error
# pylint: disable=line-too-long,missing-function-docstring
r"""A config to load and evaluate models.
The runtime varies widely depending on the model, but each one should reproduce
the corresponding paper's numbers.
This configuration makes use of the "arg" to get_config to select which model
to run, so a few examples are given below:
Run and evaluate a BiT-M ResNet-50x1 model that was transferred to i1k:
big_vision.tools.eval_only \
--config big_vision/configs/load_and_eval.py:name=bit_paper,batch_size=8 \
--config.model_init M-imagenet2012 --config.model.width 1 --config.model.depth 50
Run and evaluate the recommended ViT-B/32 from "how to train your vit" paper:
big_vision.tools.eval_only \
--config big_vision/configs/load_and_eval.py:name=vit_i21k,batch_size=8 \
--config.model.variant B/32 --config.model_init howto-i21k-B/32
"""
import big_vision.configs.common as bvcc
from big_vision.configs.common_fewshot import get_fewshot_lsr
from big_vision.configs.proj.image_text import lit_eval
import ml_collections as mlc
def get_config(arg='name=bit_paper,batch_size=2'):
arg = bvcc.parse_arg(arg, name='', batch_size=2)
config = mlc.ConfigDict()
config.batch_size_eval = arg.batch_size
# Just calls the function with the name given as `config`.
# Could also be a giant if-block if you're into that kind of thing.
globals()[arg.name](config)
return config
def bit_paper(config):
# We could omit init_{shapes,types} if we wanted, as they are the default.
config.init_shapes = [(1, 224, 224, 3)]
config.init_types = ['float32']
config.num_classes = 1000
config.model_name = 'bit_paper'
config.model_init = 'M-imagenet2012' # M = i21k, -imagenet2012 = fine-tuned
config.model = dict(width=1, depth=50)
config.evals = {}
config.evals.fewshot = get_fewshot_lsr()
def get_eval(split, lbl, dataset='imagenet2012_real'):
return dict(
type='classification',
data=dict(name=dataset, split=split),
loss_name='softmax_xent',
cache_final=False, # Only run once, on low-mem machine.
pp_fn=(
'decode|resize(384)|value_range(-1, 1)'
f'|onehot(1000, key="{lbl}", key_result="labels")'
'|keep("image", "labels")'
),
)
config.evals.test = get_eval('validation', 'original_label')
config.evals.real = get_eval('validation', 'real_label')
config.evals.v2 = get_eval('test', 'label', 'imagenet_v2')
def vit_i1k(config):
# We could omit init_{shapes,types} if we wanted, as they are the default.
config.init_shapes = [(1, 224, 224, 3)]
config.init_types = ['float32']
config.num_classes = 1000
config.model_name = 'vit'
config.model_init = '' # Will be set in sweep.
config.model = dict(variant='S/16', pool_type='gap', posemb='sincos2d',
rep_size=True)
config.evals = {}
config.evals.fewshot = get_fewshot_lsr()
config.evals.val = dict(
type='classification',
data=dict(name='imagenet2012', split='validation'),
pp_fn='decode|resize_small(256)|central_crop(224)|value_range(-1, 1)|onehot(1000, key="label", key_result="labels")|keep("image", "labels")',
loss_name='softmax_xent',
cache_final=False, # Only run once, on low-mem machine.
)
def mlp_mixer_i1k(config):
# We could omit init_{shapes,types} if we wanted, as they are the default.
config.init_shapes = [(1, 224, 224, 3)]
config.init_types = ['float32']
config.num_classes = 1000
config.model_name = 'mlp_mixer'
config.model_init = '' # Will be set in sweep.
config.model = dict(variant='L/16')
config.evals = {}
config.evals.fewshot = get_fewshot_lsr()
config.evals.val = dict(
type='classification',
data=dict(name='imagenet2012', split='validation'),
pp_fn='decode|resize_small(256)|central_crop(224)|value_range(-1, 1)|onehot(1000, key="label", key_result="labels")|keep("image", "labels")',
loss_name='softmax_xent',
cache_final=False, # Only run once, on low-mem machine.
)
def vit_i21k(config):
# We could omit init_{shapes,types} if we wanted, as they are the default.
config.init_shapes = [(1, 224, 224, 3)]
config.init_types = ['float32']
config.num_classes = 21843
config.model_name = 'vit'
config.model_init = '' # Will be set in sweep.
config.model = dict(variant='B/32', pool_type='tok')
config.evals = {}
config.evals.fewshot = get_fewshot_lsr()
config.evals.val = dict(
type='classification',
data=dict(name='imagenet21k', split='full[:51200]'),
pp_fn='decode|resize_small(256)|central_crop(224)|value_range(-1, 1)|onehot(21843)|keep("image", "labels")',
loss_name='sigmoid_xent',
cache_final=False, # Only run once, on low-mem machine.
)
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Pre-training ViT-S/16 on ILSVRC-2012 following https://arxiv.org/abs/2205.01580.
This should take 6-7h to finish 90ep on a TPU-v3-8 and reach 76.5%,
see the tech report for more details.
Command to run:
big_vision.train \
--config big_vision/configs/vit_s16_i1k.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'`
To run for 300ep, add `--config.total_epochs 300` to the command.
"""
import ml_collections as mlc
def get_config():
"""Config for training."""
config = mlc.ConfigDict()
config.seed = 0
config.total_epochs = 90
config.num_classes = 1000
config.loss = 'softmax_xent'
config.input = {}
config.input.data = dict(
name='imagenet2012',
split='train[:99%]',
)
config.input.batch_size = 1024
config.input.cache_raw = True # Needs up to 120GB of RAM!
config.input.shuffle_buffer_size = 250_000
pp_common = (
'|value_range(-1, 1)'
'|onehot(1000, key="{lbl}", key_result="labels")'
'|keep("image", "labels")'
)
config.input.pp = (
'decode_jpeg_and_inception_crop(224)|flip_lr|randaug(2,10)' +
pp_common.format(lbl='label')
)
pp_eval = 'decode|resize_small(256)|central_crop(224)' + pp_common
config.log_training_steps = 50
config.ckpt_steps = 1000
# Model section
config.model_name = 'vit'
config.model = dict(
variant='S/16',
rep_size=True,
pool_type='gap',
posemb='sincos2d',
)
# Optimizer section
config.grad_clip_norm = 1.0
config.optax_name = 'scale_by_adam'
config.optax = dict(mu_dtype='bfloat16')
config.lr = 0.001
config.wd = 0.0001
config.schedule = dict(warmup_steps=10_000, decay_type='cosine')
config.mixup = dict(p=0.2, fold_in=None)
# Eval section
def get_eval(split, dataset='imagenet2012'):
return dict(
type='classification',
data=dict(name=dataset, split=split),
pp_fn=pp_eval.format(lbl='label'),
loss_name=config.loss,
log_steps=2500, # Very fast O(seconds) so it's fine to run it often.
)
config.evals = {}
config.evals.train = get_eval('train[:2%]')
config.evals.minival = get_eval('train[99%:]')
config.evals.val = get_eval('validation')
config.evals.v2 = get_eval('test', dataset='imagenet_v2')
config.evals.real = get_eval('validation', dataset='imagenet2012_real')
config.evals.real.pp_fn = pp_eval.format(lbl='real_label')
return config
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long,missing-function-docstring
r"""A config for transferring vit-augreg.
Best HP selected on (mini)val, expected test results (repeated 5 times):
ViT-Augreg-B/32:
Dataset, crop, learning rate, mean (%), range (%)
- ImageNet, inception_crop, 0.03, 83.27, [83.22...83.33]
- Cifar10, resmall_crop, 0.003, 98.55, [98.46...98.6]
- Cifar100, resmall_crop, 0.01, 91.35, [91.09...91.62]
- Pets, inception_crop, 0.003, 93.78, [93.62...94.00]
- Flowers, inception_crop, 0.003, 99.43, [99.42...99.45]
Command to run:
big_vision.train \
--config big_vision/configs/transfer.py:model=vit-i21k-augreg-b/32,dataset=cifar10,crop=resmall_crop \
--workdir gs://$GS_BUCKET_NAME/big_vision/workdir/`date '+%m-%d_%H%M'` --config.lr=0.03
"""
import big_vision.configs.common as bvcc
import ml_collections as mlc
def _set_model(config, model):
"""Load pre-trained models: vit or bit."""
# Reset the head to init (of zeros) when transferring.
config.model_load = dict(dont_load=['head/kernel', 'head/bias'])
if model == 'vit-i21k-augreg-b/32':
# Load "recommended" upstream B/32 from https://arxiv.org/abs/2106.10270
config.model_name = 'vit'
config.model_init = 'howto-i21k-B/32'
config.model = dict(variant='B/32', pool_type='tok')
elif model == 'vit-s16':
config.model_name = 'vit'
config.model_init = 'i1k-s16-300ep'
config.model = dict(variant='S/16', pool_type='gap', posemb='sincos2d',
rep_size=True)
elif model == 'bit-m-r50x1':
config.model_name = 'bit_paper'
config.model_init = 'M'
config.model = dict(depth=50, width=1)
else:
raise ValueError(f'Unknown model: {model}, please define customized model.')
def _set_dataset(config, dataset, crop='inception_crop', h_res=448, l_res=384):
if dataset == 'cifar10':
_set_task(config, 'cifar10', 'train[:98%]', 'train[98%:]', 'test', 10, steps=10_000, warmup=500, crop=crop, h_res=h_res, l_res=l_res)
elif dataset == 'cifar100':
_set_task(config, 'cifar100', 'train[:98%]', 'train[98%:]', 'test', 100, steps=10_000, warmup=500, crop=crop, h_res=h_res, l_res=l_res)
elif dataset == 'imagenet2012':
_set_task(config, 'imagenet2012', 'train[:99%]', 'train[99%:]', 'validation', 1000, steps=20_000, warmup=500, crop=crop, h_res=h_res, l_res=l_res)
_set_imagenet_variants(config)
elif dataset == 'oxford_iiit_pet':
_set_task(config, 'oxford_iiit_pet', 'train[:90%]', 'train[90%:]', 'test', 37, steps=500, warmup=100, crop=crop, h_res=h_res, l_res=l_res)
elif dataset == 'oxford_flowers102':
_set_task(config, 'oxford_flowers102', 'train[:90%]', 'train[90%:]', 'test', 102, steps=500, warmup=100, crop=crop, h_res=h_res, l_res=l_res)
else:
raise ValueError(
f'Unknown dataset: {dataset}, please define customized dataset.')
def _set_task(config, dataset, train, val, test, n_cls,
steps=20_000, warmup=500, lbl='label', crop='resmall_crop',
flip=True, h_res=448, l_res=384):
"""Vision task with val and test splits."""
config.total_steps = steps
config.schedule = dict(
warmup_steps=warmup,
decay_type='cosine',
)
config.input.data = dict(name=dataset, split=train)
pp_common = (
'|value_range(-1, 1)|'
f'onehot({n_cls}, key="{lbl}", key_result="labels")|'
'keep("image", "labels")'
)
if crop == 'inception_crop':
pp_train = f'decode|inception_crop({l_res})'
elif crop == 'resmall_crop':
pp_train = f'decode|resize_small({h_res})|random_crop({l_res})'
elif crop == 'resize_crop':
pp_train = f'decode|resize({h_res})|random_crop({l_res})'
else:
raise ValueError(f'Unknown crop: {crop}. Must be one of: '
'inception_crop, resmall_crop, resize_crop')
if flip:
pp_train += '|flip_lr'
config.input.pp = pp_train + pp_common
pp = f'decode|resize_small({h_res})|central_crop({l_res})' + pp_common
config.num_classes = n_cls
def get_eval(split):
return dict(
type='classification',
data=dict(name=dataset, split=split),
loss_name='softmax_xent',
log_steps=100,
pp_fn=pp,
)
config.evals = dict(val=get_eval(val), test=get_eval(test))
def _set_imagenet_variants(config, h_res=448, l_res=384):
"""Evaluation tasks on ImageNet variants: v2 and real."""
pp = (f'decode|resize_small({h_res})|central_crop({l_res})'
'|value_range(-1, 1)|onehot(1000, key="{lbl}", key_result="labels")|'
'keep("image", "labels")'
)
# Special-case rename for i1k (val+test -> minival+val)
config.evals.minival = config.evals.val
config.evals.val = config.evals.test
# NOTE: keep test == val for convenience in subsequent analysis.
config.evals.real = dict(type='classification')
config.evals.real.data = dict(name='imagenet2012_real', split='validation')
config.evals.real.pp_fn = pp.format(lbl='real_label')
config.evals.real.loss_name = config.loss
config.evals.real.log_steps = 100
config.evals.v2 = dict(type='classification')
config.evals.v2.data = dict(name='imagenet_v2', split='test')
config.evals.v2.pp_fn = pp.format(lbl='label')
config.evals.v2.loss_name = config.loss
config.evals.v2.log_steps = 100
def get_config(arg=None):
"""Config for adaptation."""
arg = bvcc.parse_arg(arg, model='vit', dataset='cifar10', crop='resmall_crop',
h_res=448, l_res=384, runlocal=False)
config = mlc.ConfigDict()
config.input = {}
config.input.batch_size = 512 if not arg.runlocal else 8
config.input.shuffle_buffer_size = 50_000 if not arg.runlocal else 100
config.log_training_steps = 10
config.ckpt_steps = 1000
config.ckpt_timeout = 600
# Optimizer section
config.optax_name = 'big_vision.momentum_hp'
config.grad_clip_norm = 1.0
config.wd = None # That's our default, but just being explicit here!
config.loss = 'softmax_xent'
config.lr = 0.01
config.mixup = dict(p=0.0)
config.seed = 0
_set_dataset(config, arg.dataset, arg.crop, arg.h_res, arg.l_res)
_set_model(config, arg.model)
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Pre-training ViT on ILSVRC-2012 as in https://arxiv.org/abs/2106.10270
This configuration makes use of the "arg" to get_config to select which model
to run, so a few examples are given below:
Run training of a B/16 model:
big_vision.train \
--config big_vision/configs/vit_i1k.py:variant=B/16 \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'`
Run training of a B/32 model with custom aug-strenght and 300ep:
big_vision.train \
--config big_vision/configs/vit_i1k.py:variant=B/32,aug=light1 \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
--config.total_epochs 300
"""
import big_vision.configs.common as bvcc
from big_vision.configs.common_fewshot import get_fewshot_lsr
import ml_collections as mlc
MIXUP_DEF = {
'none': dict(p=0.0, fold_in=None),
'light1': dict(p=0.0, fold_in=None),
'light2': dict(p=0.2, fold_in=None),
'medium1': dict(p=0.2, fold_in=None),
'medium2': dict(p=0.5, fold_in=None),
'strong1': dict(p=0.5, fold_in=None),
'strong2': dict(p=0.8, fold_in=None),
}
RANDAUG_DEF = {
'none': '',
'light1': 'randaug(2,0)', # Actually not nothing!
'light2': 'randaug(2,10)',
'medium1': 'randaug(2,15)',
'medium2': 'randaug(2,15)',
'strong1': 'randaug(2,20)',
'strong2': 'randaug(2,20)',
}
def get_config(arg=None):
"""Config for training."""
arg = bvcc.parse_arg(arg, variant='B/16', runlocal=False, aug='')
config = mlc.ConfigDict()
config.seed = 0
config.total_epochs = 300
config.num_classes = 1000
config.loss = 'sigmoid_xent'
config.init_head_bias = -6.9
# If this gives a KeyError, lookup Fig4 of the paper and add an entry.
# Note, this here is a good average between 30ep and 300ep, sometimes you coud
# find a slightly better setting for either of them.
aug_setting = arg.aug or {
'Ti/16': 'light1',
'S/32': 'medium1',
'S/16': 'medium2',
'B/32': 'medium2',
'B/16': 'medium2',
'L/16': 'medium2',
}[arg.variant]
config.input = dict()
config.input.data = dict(
name='imagenet2012',
split='train[:99%]',
)
config.input.batch_size = 4096
config.input.cache_raw = not arg.runlocal # Needs up to 120GB of RAM!
config.input.shuffle_buffer_size = 250_000
pp_common = (
'|value_range(-1, 1)'
'|onehot(1000, key="{lbl}", key_result="labels")'
'|keep("image", "labels")'
)
config.input.pp = (
'decode_jpeg_and_inception_crop(224)|flip_lr|' +
RANDAUG_DEF[aug_setting] +
pp_common.format(lbl='label')
)
pp_eval = 'decode|resize_small(256)|central_crop(224)' + pp_common
# Aggressive pre-fetching because our models here are small, so we not only
# can afford it, but we also need it for the smallest models to not be
# bottle-necked by the input pipeline. Play around with it for -L models tho.
config.input.prefetch = 8
config.prefetch_to_device = 4
config.log_training_steps = 50
config.ckpt_steps = 1000
# Model section
config.model_name = 'vit'
config.model = dict(
variant=arg.variant,
rep_size=True,
pool_type='tok',
)
# Optimizer section
config.grad_clip_norm = 1.0
config.optax_name = 'scale_by_adam'
config.optax = dict(mu_dtype='bfloat16')
# The modified AdaFactor we introduced in https://arxiv.org/abs/2106.04560
# almost always behaves exactly like adam, but at a fraction of the memory
# cost (specifically, adam_bf16 = +1.5M, adafactor = +0.5M), hence it is a
# good idea to try it when you are memory-bound!
# config.optax_name = 'big_vision.scale_by_adafactor'
# A good flag to play with when hitting instabilities, is the following:
# config.optax = dict(beta2_cap=0.95)
config.lr = 0.001
config.wd = 0.0001
config.schedule = dict(warmup_steps=10_000, decay_type='cosine')
config.mixup = MIXUP_DEF[aug_setting]
# Eval section
def get_eval(split, dataset='imagenet2012'):
return dict(
type='classification',
data=dict(name=dataset, split=split),
pp_fn=pp_eval.format(lbl='label'),
loss_name=config.loss,
log_steps=2500, # Very fast O(seconds) so it's fine to run it often.
cache_final=not arg.runlocal,
)
config.evals = {}
config.evals.train = get_eval('train[:2%]')
config.evals.minival = get_eval('train[99%:]')
config.evals.val = get_eval('validation')
config.evals.v2 = get_eval('test', dataset='imagenet_v2')
config.evals.real = get_eval('validation', dataset='imagenet2012_real')
config.evals.real.pp_fn = pp_eval.format(lbl='real_label')
config.fewshot = get_fewshot_lsr(runlocal=arg.runlocal)
config.fewshot.log_steps = 10_000
# Make a few things much smaller for quick local debugging testruns.
if arg.runlocal:
config.input.shuffle_buffer_size = 10
config.input.batch_size = 8
config.input.cache_raw = False
config.evals.train.data.split = 'train[:16]'
config.evals.minival.data.split = 'train[:16]'
config.evals.val.data.split = 'validation[:16]'
config.evals.v2.data.split = 'test[:16]'
config.evals.real.data.split = 'validation[:16]'
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""A few things commonly used across A LOT of config files."""
import string
import ml_collections as mlc
def input_for_quicktest(config_input, quicktest):
if quicktest:
config_input.batch_size = 8
config_input.shuffle_buffer_size = 10
config_input.cache_raw = False
def parse_arg(arg, lazy=False, **spec):
"""Makes ConfigDict's get_config single-string argument more usable.
Example use in the config file:
import big_vision.configs.common as bvcc
def get_config(arg):
arg = bvcc.parse_arg(arg,
res=(224, int),
runlocal=False,
schedule='short',
)
# ...
config.shuffle_buffer = 250_000 if not arg.runlocal else 50
Ways that values can be passed when launching:
--config amazing.py:runlocal,schedule=long,res=128
--config amazing.py:res=128
--config amazing.py:runlocal # A boolean needs no value for "true".
--config amazing.py:runlocal=False # Explicit false boolean.
--config amazing.py:128 # The first spec entry may be passed unnamed alone.
Uses strict bool conversion (converting 'True', 'true' to True, and 'False',
'false', '' to False).
Args:
arg: the string argument that's passed to get_config.
lazy: allow lazy parsing of arguments, which are not in spec. For these,
the type is auto-extracted in dependence of most complex possible type.
**spec: the name and default values of the expected options.
If the value is a tuple, the value's first element is the default value,
and the second element is a function called to convert the string.
Otherwise the type is automatically extracted from the default value.
Returns:
ConfigDict object with extracted type-converted values.
"""
# Normalize arg and spec layout.
arg = arg or '' # Normalize None to empty string
spec = {k: (v if isinstance(v, tuple) else (v, get_type(v)))
for k, v in spec.items()}
result = mlc.ConfigDict(type_safe=False) # For convenient dot-access only.
# Expand convenience-cases for a single parameter without = sign.
if arg and ',' not in arg and '=' not in arg:
# (think :runlocal) If it's the name of sth in the spec (or there is no
# spec), it's that in bool.
if arg in spec or not spec:
arg = f'{arg}=True'
# Otherwise, it is the value for the first entry in the spec.
else:
arg = f'{list(spec.keys())[0]}={arg}'
# Yes, we rely on Py3.7 insertion order!
# Now, expand the `arg` string into a dict of keys and values:
raw_kv = {raw_arg.split('=')[0]:
raw_arg.split('=', 1)[-1] if '=' in raw_arg else 'True'
for raw_arg in arg.split(',') if raw_arg}
# And go through the spec, using provided or default value for each:
for name, (default, type_fn) in spec.items():
val = raw_kv.pop(name, None)
result[name] = type_fn(val) if val is not None else default
if raw_kv:
if lazy: # Process args which are not in spec.
for k, v in raw_kv.items():
result[k] = autotype(v)
else:
raise ValueError(f'Unhandled config args remain: {raw_kv}')
return result
def get_type(v):
"""Returns type of v and for boolean returns a strict bool function."""
if isinstance(v, bool):
def strict_bool(x):
assert x.lower() in {'true', 'false', ''}
return x.lower() == 'true'
return strict_bool
return type(v)
def autotype(x):
"""Auto-converts string to bool/int/float if possible."""
assert isinstance(x, str)
if x.lower() in {'true', 'false'}:
return x.lower() == 'true' # Returns as bool.
try:
return int(x) # Returns as int.
except ValueError:
try:
return float(x) # Returns as float.
except ValueError:
return x # Returns as str.
def pack_arg(**kw):
"""Packs key-word args as a string to be parsed by `parse_arg()`."""
return ','.join([f'{k}={v}' for k, v in kw.items()])
def _get_field_ref(config_dict, field_name):
path = field_name.split('.')
for field in path[:-1]:
config_dict = getattr(config_dict, field)
return config_dict.get_ref(path[-1])
def format_str(format_string, config):
"""Format string with reference fields from config.
This makes it easy to build preprocess strings that contain references to
fields tha are edited after. E.g.:
```
config = mlc.ConficDict()
config.res = (256, 256)
config.pp = bvcc.format_str('resize({res})', config)
...
# if config.res is modified (e.g. via sweeps) it will propagate to pp field:
config.res = (512, 512)
assert config.pp == 'resize((512, 512))'
```
Args:
format_string: string to format with references.
config: ConfigDict to get references to format the string.
Returns:
A reference field which renders a string using references to config fields.
"""
output = ''
parts = string.Formatter().parse(format_string)
for (literal_text, field_name, format_spec, conversion) in parts:
assert not format_spec and not conversion
output += literal_text
if field_name:
output += _get_field_ref(config, field_name).to_str()
return output
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Most common few-shot eval configuration."""
import ml_collections as mlc
def get_fewshot_lsr(target_resolution=224, resize_resolution=256,
runlocal=False):
"""Returns a standard-ish fewshot eval configuration."""
config = mlc.ConfigDict()
config.type = 'fewshot_lsr'
config.representation_layer = 'pre_logits'
config.log_steps = 25_000
config.datasets = {
'caltech': ('caltech101', 'train', 'test'), # copybara:srtip
'cars': ('cars196:2.1.0', 'train', 'test'),
'cifar100': ('cifar100', 'train', 'test'),
'dtd': ('dtd', 'train', 'test'),
# The first 65000 ImageNet samples have at least 30 shots per any class.
# Commented out by default because needs manual download.
# 'imagenet': ('imagenet2012', 'train[:65000]', 'validation'),
'pets': ('oxford_iiit_pet', 'train', 'test'),
'uc_merced': ('uc_merced', 'train[:1000]', 'train[1000:]'),
} if not runlocal else {
'pets': ('oxford_iiit_pet', 'train', 'test'),
}
config.pp_train = f'decode|resize({resize_resolution})|central_crop({target_resolution})|value_range(-1,1)|keep("image", "label")'
config.pp_eval = f'decode|resize({resize_resolution})|central_crop({target_resolution})|value_range(-1,1)|keep("image", "label")'
config.shots = (1, 5, 10, 25)
config.l2_reg = 2.0 ** 10
config.num_seeds = 3
config.display_first = [('imagenet', 10)] if not runlocal else [('pets', 10)]
config.prefix = '' # No prefix as we do already prefix with a/ z/ and zz/
return config
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for pre-training BiT on ImageNet-21k.
This config relies on the Imagenet-21k tfds dataset, which is not yet
available publicly in TFDS. We intend to add the dataset to public TFDS soon,
and this config will then be runnable.
"""
from big_vision.configs.common_fewshot import get_fewshot_lsr
import ml_collections as mlc
def get_config():
"""Config for training on imagenet-21k."""
config = mlc.ConfigDict()
config.seed = 0
config.total_epochs = 90
config.num_classes = 21843
config.init_head_bias = -10.0
config.loss = 'sigmoid_xent'
config.input = dict()
config.input.data = dict(
name='imagenet21k',
split='full[51200:]',
)
config.input.batch_size = 4096
config.input.shuffle_buffer_size = 250_000 # Per host, so small-ish is ok.
pp_common = '|value_range(-1, 1)|onehot({onehot_args})|keep("image", "labels")'
pp_common_i21k = pp_common.format(onehot_args=f'{config.num_classes}')
pp_common_i1k = pp_common.format(onehot_args='1000, key="label", key_result="labels"')
config.input.pp = 'decode_jpeg_and_inception_crop(224)|flip_lr' + pp_common_i21k
pp_eval = 'decode|resize_small(256)|central_crop(224)'
config.log_training_steps = 50
config.ckpt_steps = 1000
# Model section
config.model_name = 'bit_paper'
config.model = dict(depth=50, width=1.0)
# Optimizer section
config.optax_name = 'big_vision.momentum_hp'
config.grad_clip_norm = 1.0
# linear scaling rule. Don't forget to sweep if sweeping batch_size.
config.lr = (0.03 / 256) * config.input.batch_size
config.wd = (3e-5 / 256) * config.input.batch_size
config.schedule = dict(decay_type='cosine', warmup_steps=5000)
# Evaluations on i21k itself.
def eval_i21k(split):
return dict(
type='classification',
data={**config.input.data, 'split': split},
pp_fn=pp_eval + pp_common_i21k,
loss_name=config.loss,
log_steps=1000, # Very fast O(seconds) so it's fine to run it often.
)
config.evals = {}
config.evals.test = eval_i21k('full[:25_600]')
config.evals.val = eval_i21k('full[25_600:51_200]')
config.evals.train = eval_i21k('full[51_200:76_800]')
# Few-shot evaluators
config.evals.fewshot = get_fewshot_lsr()
config.evals.fewshot.log_steps = 25_000
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Pre-training BiT on ILSVRC-2012 as in https://arxiv.org/abs/1912.11370
Run training of a BiT-ResNet-50x1 variant, which takes ~32min on v3-128:
big_vision.train \
--config big_vision/configs/bit_i1k.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
--config.model.depth 50 --config.model.width 1
"""
# from big_vision.configs.common_fewshot import get_fewshot_lsr
import ml_collections as mlc
def get_config(runlocal=False):
"""Config for training on ImageNet-1k."""
config = mlc.ConfigDict()
config.seed = 0
config.total_epochs = 90
config.num_classes = 1000
config.loss = 'softmax_xent'
config.input = dict()
config.input.data = dict(
name='imagenet2012',
split='train[:99%]',
)
config.input.batch_size = 4096 if not runlocal else 32
config.input.cache_raw = not runlocal # Needs up to 120GB of RAM!
config.input.shuffle_buffer_size = 250_000 if not runlocal else 10_000 # Per host.
pp_common = '|onehot(1000, key="{lbl}", key_result="labels")'
pp_common += '|value_range(-1, 1)|keep("image", "labels")'
config.input.pp = 'decode_jpeg_and_inception_crop(224)|flip_lr' + pp_common.format(lbl='label')
pp_eval = 'decode|resize_small(256)|central_crop(224)' + pp_common
config.log_training_steps = 50
config.ckpt_steps = 1000
# Model section
config.model_name = 'bit'
config.model = dict(
depth=50, # You can also pass e.g. [3, 5, 10, 2]
width=1.0,
)
# Optimizer section
config.optax_name = 'big_vision.momentum_hp'
config.grad_clip_norm = 1.0
# linear scaling rule. Don't forget to sweep if sweeping batch_size.
config.wd = (1e-4 / 256) * config.input.batch_size
config.lr = (0.1 / 256) * config.input.batch_size
config.schedule = dict(decay_type='cosine', warmup_steps=1000)
# Eval section
def get_eval(split, dataset='imagenet2012'):
return dict(
type='classification',
data=dict(name=dataset, split=split),
pp_fn=pp_eval.format(lbl='label'),
loss_name=config.loss,
log_steps=1000, # Very fast O(seconds) so it's fine to run it often.
cache_final=not runlocal,
)
config.evals = {}
config.evals.train = get_eval('train[:2%]')
config.evals.minival = get_eval('train[99%:]')
config.evals.val = get_eval('validation')
config.evals.v2 = get_eval('test', dataset='imagenet_v2')
config.evals.real = get_eval('validation', dataset='imagenet2012_real')
config.evals.real.pp_fn = pp_eval.format(lbl='real_label')
# config.evals.fewshot = get_fewshot_lsr(runlocal=runlocal)
# config.evals.fewshot.log_steps = 1000
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for pre-training BiT on ImageNet-21k.
This config relies on the Imagenet-21k tfds dataset, which is not yet
available publicly in TFDS. We intend to add the dataset to public TFDS soon,
and this config will then be runnable.
"""
import big_vision.configs.common as bvcc
from big_vision.configs.common_fewshot import get_fewshot_lsr
import ml_collections as mlc
MIXUP_DEF = {
'none': dict(p=0.0, fold_in=None),
'light1': dict(p=0.0, fold_in=None),
'light2': dict(p=0.2, fold_in=None),
'medium1': dict(p=0.2, fold_in=None),
'medium2': dict(p=0.5, fold_in=None),
'strong1': dict(p=0.5, fold_in=None),
'strong2': dict(p=0.8, fold_in=None),
}
RANDAUG_DEF = {
'none': '',
'light1': 'randaug(2,0)', # Actually not nothing!
'light2': 'randaug(2,10)',
'medium1': 'randaug(2,15)',
'medium2': 'randaug(2,15)',
'strong1': 'randaug(2,20)',
'strong2': 'randaug(2,20)',
}
def get_config(arg=None):
"""Config for training."""
arg = bvcc.parse_arg(arg, variant='B/16', runlocal=False, aug=None)
config = mlc.ConfigDict()
config.seed = 0
config.total_epochs = 300
config.num_classes = 21843
config.init_head_bias = -10.0
config.loss = 'sigmoid_xent'
# If this gives a KeyError, lookup Fig4 of the paper and add an entry.
# Note, this here is a good average between 30ep and 300ep, sometimes you coud
# find a slightly better setting for either of them.
aug_setting = {
'Ti/16': 'none',
'S/32': 'none',
'S/16': 'light1',
'B/32': 'light2',
'B/16': 'light2',
'L/16': 'medium2',
}[arg.variant]
config.input = dict()
config.input.data = dict(
name='imagenet21k',
split='full[51200:]',
)
config.input.batch_size = 4096
config.input.shuffle_buffer_size = 250_000 # Per host, so small-ish is ok.
pp_common = '|value_range(-1, 1)|onehot({onehot_args})|keep("image", "labels")'
pp_common_i21k = pp_common.format(onehot_args=f'{config.num_classes}')
pp_common_i1k = pp_common.format(onehot_args='1000, key="label", key_result="labels"')
config.input.pp = f'decode_jpeg_and_inception_crop(224)|flip_lr|{RANDAUG_DEF[aug_setting]}' + pp_common_i21k
pp_eval = 'decode|resize_small(256)|central_crop(224)'
# Aggressive pre-fetching because our models here are small, so we not only
# can afford it, but we also need it for the smallest models to not be
# bottle-necked by the input pipeline. Play around with it for -L models tho.
config.input.prefetch = 8
config.prefetch_to_device = 4
config.log_training_steps = 50
config.ckpt_steps = 1000
# Model section
config.model_name = 'vit'
config.model = dict(variant=arg.variant, pool_type='gap', posemb='learn')
# Optimizer section
config.optax_name = 'scale_by_adam'
config.optax = dict(mu_dtype='bfloat16')
config.grad_clip_norm = 1.0
config.lr = 0.001
config.wd = 0.0001
config.schedule = dict(warmup_steps=10_000, decay_type='cosine')
config.mixup = MIXUP_DEF[aug_setting]
# Evaluations on i21k itself.
def eval_i21k(split):
return dict(
type='classification',
data={**config.input.data, 'split': split},
pp_fn=pp_eval + pp_common_i21k,
loss_name=config.loss,
log_steps=1000, # Very fast O(seconds) so it's fine to run it often.
)
config.evals = {}
config.evals.test = eval_i21k('full[:25_600]')
config.evals.val = eval_i21k('full[25_600:51_200]')
config.evals.train = eval_i21k('full[51_200:76_800]')
# Few-shot evaluators
config.evals.fewshot = get_fewshot_lsr(runlocal=arg.runlocal)
config.evals.fewshot.log_steps = 25_000
# Make a few things much smaller for quick local debugging testruns.
if arg.runlocal:
config.input.shuffle_buffer_size = 10
config.input.batch_size = 8
config.evals.test.data.split = 'full[:16]'
config.evals.train.data.split = 'full[:16]'
config.evals.val.data.split = 'full[:16]'
config.evals.i1k_val.data.split = 'validation[:16]'
config.evals.i1k_v2.data.split = 'test[:16]'
config.evals.i1k_a.data.split = 'test[:16]'
config.evals.i1k_r.data.split = 'test[:16]'
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Distillation of ViT models into FlexiViT on ImageNet1k.
Run training of the -S variant for 90ep:
big_vision.trainers.proj.flexi.distill \
--config big_vision/configs/proj/flexivit/i1k_deit3_distill.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
--config.total_epochs 90 --config.variant S
Logdir for one reproduction run:
- gs://big_vision/flexivit/deit3_i1k_s_90ep_12-15_2254
Timing on Cloud:
- S on v3-32: Walltime:10h16m (4h39m eval)
Note that we did not optimize the input for Cloud,
with tuned caching and prefetching, we should be able to get:
- S on v3-32: Walltime: ~6h30m (~1h30m eval)
- B on v3-32: Walltime: ~16h00m (~2h30m eval)
"""
import big_vision.configs.common as bvcc
def get_config(arg=None):
"""Config for distilling ViT on ImageNet1k."""
c = bvcc.parse_arg(arg, runlocal=False, res=240)
c.seed = 0
c.total_epochs = 90
c.num_classes = 1000
c.loss = 'softmax_xent'
c.input = {}
c.input.data = dict(
name='imagenet2012',
split='train[:99%]',
)
c.input.batch_size = 1024 if not c.runlocal else 8
c.input.cache_raw = False # Needs up to 120GB of RAM!
c.input.shuffle_buffer_size = 250_000 if not c.runlocal else 10
c.log_training_steps = 50
c.ckpt_steps = 1000
# Model section
c.variant = 'B'
init = bvcc.format_str('deit3_{variant}_384_1k', c)
c.student_name = 'proj.flexi.vit'
c.student_init = init
c.student = dict(variant=c.get_ref('variant'), pool_type='tok', patch_size=(16, 16))
c.teachers = ['prof'] # You could even add multiple.
c.prof_name = 'vit'
c.prof_init = init
c.prof = dict(variant=c.get_ref('variant'), pool_type='tok', patch_size=(16, 16))
pp_label = '|onehot(1000, key="{lbl}", key_result="labels")|keep("image", "prof", "labels")'
c.input.pp = (
f'decode|inception_crop|flip_lr'
'|copy("image", "prof")'
f'|resize({c.res})|value_range'
'|resize(384, key="prof")|value_range(key="prof")'
+ pp_label.format(lbl='label')
)
pp_eval_both = (
'decode|copy("image", "prof")|'
f'|resize({c.res//7*8})|central_crop({c.res})|value_range'
f'|resize({384//7*8}, key="prof")|central_crop(384, key="prof")|value_range(key="prof")|'
)
pp_eval_student = (
f'decode|resize({c.res//7*8})|central_crop({c.res})|value_range(-1, 1)'
)
pp_eval_prof = (
f'decode|resize({384//7*8})|central_crop(384)|value_range(outkey="prof")'
)
c.mixup = dict(p=1.0, n=2)
# Distillation settings
c.distance = 'kl'
c.distance_kw = dict(t=1.0)
# Optimizer section
c.grad_clip_norm = 1.0
c.optax_name = 'scale_by_adam'
c.optax = dict(mu_dtype='bfloat16')
c.lr = 1e-4
c.wd = 1e-5
c.schedule = dict(warmup_steps=5000, decay_type='cosine')
# Define the model parameters which are flexible:
c.flexi = dict()
c.flexi.seqhw = dict(
# The settings to sample from. Corresponding patch-sizes at 240px:
# 48, 40, 30, 24, 20, 16, 15, 12, 10, 8
v=(5, 6, 8, 10, 12, 15, 16, 20, 24, 30),
# The probabilities/weights of them. Default uniform.
p=(1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
)
# Eval section
def mksplit(split):
if c.runlocal:
return split.split('[')[0] + '[:16]'
return split
minitrain_split = mksplit('train[:2%]')
minival_split = mksplit('train[99%:]')
val_split = mksplit('validation')
test_split = mksplit('test')
c.aggressive_cache = False
def get_eval(s, split, dataset='imagenet2012'):
return dict(
type='classification',
pred=f'student_seqhw={s}',
data=dict(name=dataset, split=split),
pp_fn=pp_eval_student + pp_label.format(lbl='label'),
loss_name='sigmoid_xent',
log_percent=0.05,
cache_final=False,
)
c.evals = {}
for s in c.flexi.seqhw.v:
c.evals[f'student_minitrain_{s:02d}'] = get_eval(s, minitrain_split)
c.evals[f'student_minival_{s:02d}'] = get_eval(s, minival_split)
c.evals[f'student_val_{s:02d}'] = get_eval(s, val_split)
c.evals[f'student_v2_{s:02d}'] = get_eval(s, test_split, 'imagenet_v2')
c.evals[f'student_a_{s:02d}'] = get_eval(s, test_split, 'imagenet_a')
c.evals[f'student_r_{s:02d}'] = get_eval(s, test_split, 'imagenet_r')
c.evals[f'student_real_{s:02d}'] = get_eval(s, val_split, 'imagenet2012_real')
c.evals[f'student_real_{s:02d}'].pp_fn = pp_eval_student + pp_label.format(lbl='real_label')
def get_eval_t(split, dataset='imagenet2012'):
return dict(
type='classification',
pred='prof',
data=dict(name=dataset, split=split),
pp_fn=pp_eval_prof + pp_label.format(lbl='label'),
loss_name='sigmoid_xent',
log_percent=0.5, # Teacher is fixed, so eval just for plots.
cache_final=False,
)
c.evals.teacher_minitrain = get_eval_t(minitrain_split)
c.evals.teacher_minival = get_eval_t(minival_split)
c.evals.teacher_val = get_eval_t(val_split)
c.evals.teacher_v2 = get_eval_t(test_split, 'imagenet_v2')
c.evals.teacher_a = get_eval_t(test_split, 'imagenet_a')
c.evals.teacher_r = get_eval_t(test_split, 'imagenet_r')
c.evals.teacher_real = get_eval_t(val_split, 'imagenet2012_real')
c.evals.teacher_real.pp_fn = pp_eval_prof + pp_label.format(lbl='real_label')
# Distance evaluators
def get_dist(split, s):
return dict(
type='proj.distill.distance',
pred=f'student_seqhw={s}_prof',
data=dict(name='imagenet2012', split=split),
pp_fn=pp_eval_both + '|keep("image", "prof")',
log_percent=0.05,
distances=({'kind': 'kl'}, {'kind': 'logsoftmax_euclidean'},
{'kind': 'agree', 'k': 1}, {'kind': 'agree', 'k': 5}),
cache_final=False,
)
for s in c.flexi.seqhw.v:
c.evals[f'dist_minitrain_{s:02d}'] = get_dist(minitrain_split, s)
c.evals[f'dist_val_{s:02d}'] = get_dist(val_split, s)
return c |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long,missing-function-docstring
r"""A config to run timing for FlexiViT (only inference, no I/O etc.).
big_vision.tools.eval_only \
--config big_vision/configs/proj/flexivit/timing.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
--config.total_epochs 90
"""
from ml_collections import ConfigDict
def get_config():
c = ConfigDict()
shape = (240, 240, 3)
c.batch_size = 8 # swept
c.init_shapes = [(1, *shape)]
c.representation_layer = 'pre_logits'
# Creating complete model using all params, the sweep will go over variants.
c.model_name = 'xp.flexivit.vit'
c.model = dict(
variant='B',
pool_type='tok',
patch_size=(10, 10), # Like deit@384
seqhw=(24, 24),
)
c.num_classes = 0
c.evals = {}
c.evals.timing = dict(
type='timing',
input_shapes=[shape],
timing=True,
pred_kw=dict(outputs=('pre_logits',)),
)
return c |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Pre-training flexible-seqlen ViT on ImageNet-21k following (internal link).
This config is for reference, we never ran it on public infrastructure.
big_vision.trainers.proj.flexi.train \
--config big_vision/configs/proj/flexivit/i21k_sup.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
--config.total_epochs 90
"""
import big_vision.configs.common as bvcc
def get_config(arg=None):
"""Config for training."""
# 240px is nice because it's divisible by
# [240, 120, 80, 60, 48, 40, 30, 24, 20, 16, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1]
c = bvcc.parse_arg(arg, runlocal=False, res=240)
c.seed = 0
c.total_epochs = 90
c.num_classes = 21843
c.init_head_bias = -10.0
c.loss = 'sigmoid_xent'
c.input = dict()
c.input.data = dict(
name='imagenet21k',
split='full[51200:]',
)
c.input.batch_size = 4096 if not c.runlocal else 8
c.input.shuffle_buffer_size = 250_000 if not c.runlocal else 25
pp_common = '|value_range(-1, 1)|onehot({onehot_args})|keep("image", "labels")'
pp_common_i21k = pp_common.format(onehot_args=f'{c.num_classes}')
pp_common_i1k = pp_common.format(onehot_args='1000, key="{lbl}", key_result="labels"')
c.input.pp = f'decode_jpeg_and_inception_crop({c.res})|flip_lr|randaug(2,10)' + pp_common_i21k
def pp_eval(res=c.res):
return f'decode|resize_small({res//7*8})|central_crop({res})'
# Aggressive pre-fetching because our models here are small, so we not only
# can afford it, but we also need it for the smallest models to not be
# bottle-necked by the input pipeline. Play around with it for -L models tho.
c.input.prefetch = 8
c.prefetch_to_device = 4
c.log_training_steps = 50
c.ckpt_steps = 1000
# Model section
c.model_name = 'proj.flexi.vit'
c.model = dict(
variant='B',
pool_type='tok',
posemb='learn',
# patch_size=(32, 32),
patch_size=(8, 8),
posemb_size=(7, 7),
seqhw=None, # Dynamic!
)
# Define the model parameters which are flexible:
c.flexi = dict()
c.flexi.seqhw = dict(
# The settings to sample from. Corresponding patch-sizes at 240px:
# 48, 40, 30, 24, 20, 16, 15, 12, 10, 8
v=(5, 6, 8, 10, 12, 15, 16, 20, 24, 30),
# The probabilities/weights of them. Default uniform.
p=(1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
)
# Optimizer section
c.optax_name = 'scale_by_adam'
c.optax = dict(mu_dtype='bfloat16')
c.grad_clip_norm = 1.0
c.lr = 0.001
c.wd = 0.0001
c.schedule = dict(warmup_steps=10_000, decay_type='cosine')
c.mixup = dict(p=0.2, fold_in=None)
def mksplit(split):
if c.runlocal:
return split.split('[')[0] + '[:16]'
return split
# Evaluations on i21k itself.
def eval_i21k(s, split):
return dict(
type='classification',
pred=f'predict_seqhw={s}',
data={**c.input.data, 'split': mksplit(split)},
pp_fn=pp_eval() + pp_common_i21k,
loss_name=c.loss,
log_steps=5000, # Very fast O(seconds) so it's fine to run it often.
)
c.evals = {}
for s in c.flexi.seqhw.v:
c.evals[f'test{s:02d}'] = eval_i21k(s, 'full[:25_600]')
c.evals[f'val{s:02d}'] = eval_i21k(s, 'full[25_600:51_200]')
c.evals[f'train{s:02d}'] = eval_i21k(s, 'full[51_200:76_800]')
# Evaluations on ImageNet1k variants by label-mapping.
def eval_i1k(s, dataset, split, lblmap):
return dict(
type='classification_with_labelmap',
pred=f'predict_seqhw={s}',
data=dict(name=dataset, split=mksplit(split)),
pp_fn=pp_eval() + pp_common_i1k.format(lbl='label'),
loss_name=c.loss,
log_steps=5000, # Very fast O(seconds) so it's fine to run it often.
label_mapping=lblmap,
)
for s in c.flexi.seqhw.v:
c.evals[f'i1k_val{s:02d}'] = eval_i1k(s, 'imagenet2012', 'validation', 'i1k_i21k')
c.evals[f'i1k_v2{s:02d}'] = eval_i1k(s, 'imagenet_v2', 'test', 'i1k_i21k')
c.evals[f'i1k_a{s:02d}'] = eval_i1k(s, 'imagenet_a', 'test', 'i1ka_i21k')
c.evals[f'i1k_r{s:02d}'] = eval_i1k(s, 'imagenet_r', 'test', 'i1kr_i21k')
c.evals[f'i1k_real{s:02d}'] = eval_i1k(s, 'imagenet2012_real', 'validation', 'i1k_i21k')
c.evals[f'i1k_real{s:02d}'].pp_fn = pp_eval() + pp_common_i1k.format(lbl='real_label')
# TODO: add objectnet.
# Few-shot evaluators not added for overkill reasons for now.
return c
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Distill flexible-seqlen ViT on ImageNet-21k from (internal link) B/8.
This config is for reference, we never ran it on public infrastructure.
big_vision.trainers.proj.flexi.distill \
--config big_vision/configs/proj/flexivit/i21k_distill.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
--config.total_epochs 90
"""
import big_vision.configs.common as bvcc
def get_config(arg=None):
"""Config for training."""
# 240px is nice because it's divisible by
# [240, 120, 80, 60, 48, 40, 30, 24, 20, 16, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1]
c = bvcc.parse_arg(arg, runlocal=False, res=240)
c.seed = 0
c.total_epochs = 90
c.num_classes = 21843
c.init_head_bias = -10.0
c.loss = 'sigmoid_xent'
c.input = dict()
c.input.data = dict(
name='imagenet21k',
split='full[51200:]',
)
c.input.batch_size = 4096 if not c.runlocal else 8
c.input.shuffle_buffer_size = 250_000 if not c.runlocal else 25
pp_label_i21k = f'|onehot({c.num_classes})|keep("image", "prof", "labels")'
pp_label_i1k = '|onehot(1000, key="{lbl}", key_result="labels")|keep("image", "prof", "labels")'
c.input.pp = (
f'decode|inception_crop|flip_lr|copy("image", "prof")'
f'|resize({c.res})|value_range(-1, 1)'
f'|resize(224, outkey="prof")|value_range(-1, 1, key="prof")'
+ pp_label_i21k
)
pp_eval_both = (
'decode|copy("image", "prof")|'
f'|resize_small({c.res//7*8})|central_crop({c.res})|value_range(-1, 1)'
f'|resize_small(256, key="prof")|central_crop(224, key="prof")|value_range(-1, 1, key="prof")|'
)
pp_eval_student = (
f'decode|resize({c.res//7*8})|central_crop({c.res})|value_range(-1, 1)'
)
pp_eval_prof = (
'decode|resize(256)|central_crop(224)|value_range(-1, 1, outkey="prof")'
)
# Aggressive pre-fetching because our models here are small, so we not only
# can afford it, but we also need it for the smallest models to not be
# bottle-necked by the input pipeline. Play around with it for -L models tho.
c.input.prefetch = 8
c.prefetch_to_device = 4
c.log_training_steps = 50
c.ckpt_steps = 1000
# Model section
init = 'howto-i21k-B/8'
c.student_name = 'proj.flexi.vit'
c.student_init = init
c.student = dict(variant='B', pool_type='tok', patch_size=(8, 8))
c.teachers = ['prof'] # You could even add multiple.
c.prof_name = 'vit'
c.prof_init = init
c.prof = dict(variant='B/8', pool_type='tok')
# Define the model parameters which are flexible:
c.flexi = dict()
c.flexi.seqhw = dict(
# The settings to sample from. Corresponding patch-sizes at 240px:
# 48, 40, 30, 24, 20, 16, 15, 12, 10, 8
v=(5, 6, 8, 10, 12, 15, 16, 20, 24, 30),
# The probabilities/weights of them. Default uniform.
p=(1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
)
# Distillation settings
c.distance = 'kl'
c.distance_kw = dict(t=1.0)
# Optimizer section
c.optax_name = 'scale_by_adam'
c.optax = dict(mu_dtype='bfloat16')
c.grad_clip_norm = 1.0
c.lr = 1e-4
c.wd = 1e-5
c.schedule = dict(warmup_steps=5000, decay_type='cosine')
c.mixup = dict(p=1.0)
####
# Preparing for evals
c.evals = {}
def mksplit(split):
if c.runlocal:
return split.split('[')[0] + '[:16]'
return split
####
# Student evals
# Evaluations on i21k itself.
def eval_i21k(s, split):
return dict(
type='classification',
pred=f'student_seqhw={s}',
data={**c.input.data, 'split': mksplit(split)},
pp_fn=pp_eval_student + pp_label_i21k,
loss_name=c.loss,
log_steps=5000, # Very fast O(seconds) so it's fine to run it often.
)
for s in c.flexi.seqhw.v:
c.evals[f'student_test{s:02d}'] = eval_i21k(s, 'full[:25_600]')
c.evals[f'student_val{s:02d}'] = eval_i21k(s, 'full[25_600:51_200]')
c.evals[f'student_minitrain{s:02d}'] = eval_i21k(s, 'full[51_200:76_800]')
# Evaluations on ImageNet1k variants by label-mapping.
def eval_i1k(s, dataset, split, lblmap):
return dict(
type='classification_with_labelmap',
pred=f'student_seqhw={s}',
data=dict(name=dataset, split=mksplit(split)),
pp_fn=pp_eval_student + pp_label_i1k.format(lbl='label'),
loss_name=c.loss,
log_steps=5000, # Very fast O(seconds) so it's fine to run it often.
label_mapping=lblmap,
)
for s in c.flexi.seqhw.v:
c.evals[f'student_i1k_val{s:02d}'] = eval_i1k(s, 'imagenet2012', 'validation', 'i1k_i21k')
c.evals[f'student_i1k_v2{s:02d}'] = eval_i1k(s, 'imagenet_v2', 'test', 'i1k_i21k')
c.evals[f'student_i1k_a{s:02d}'] = eval_i1k(s, 'imagenet_a', 'test', 'i1ka_i21k')
c.evals[f'student_i1k_r{s:02d}'] = eval_i1k(s, 'imagenet_r', 'test', 'i1kr_i21k')
c.evals[f'student_i1k_real{s:02d}'] = eval_i1k(s, 'imagenet2012_real', 'validation', 'i1k_i21k')
c.evals[f'student_i1k_real{s:02d}'].pp_fn = pp_eval_student + pp_label_i1k.format(lbl='real_label')
# TODO: add objectnet.
####
# Teacher evals
# Evaluations on i21k itself.
def eval_i21k_t(split):
return dict(
type='classification',
pred='prof',
data={**c.input.data, 'split': mksplit(split)},
pp_fn=pp_eval_prof + pp_label_i21k,
loss_name=c.loss,
log_steps=5000, # Very fast O(seconds) so it's fine to run it often.
)
c.evals.teacher_test = eval_i21k_t('full[:25_600]')
c.evals.teacher_val = eval_i21k_t('full[25_600:51_200]')
c.evals.teacher_minitrain = eval_i21k_t('full[51_200:76_800]')
# Evaluations on ImageNet1k variants by label-mapping.
def eval_i1k_t(dataset, split, lblmap):
return dict(
type='classification_with_labelmap',
pred='prof',
data=dict(name=dataset, split=mksplit(split)),
pp_fn=pp_eval_prof + pp_label_i1k.format(lbl='label'),
loss_name=c.loss,
log_percent=0.5, # Teacher is fixed, so eval just for plots.
label_mapping=lblmap,
)
c.evals.teacher_i1k_val = eval_i1k_t('imagenet2012', 'validation', 'i1k_i21k')
c.evals.teacher_i1k_v2 = eval_i1k_t('imagenet_v2', 'test', 'i1k_i21k')
c.evals.teacher_i1k_a = eval_i1k_t('imagenet_a', 'test', 'i1ka_i21k')
c.evals.teacher_i1k_r = eval_i1k_t('imagenet_r', 'test', 'i1kr_i21k')
c.evals.teacher_i1k_real = eval_i1k_t('imagenet2012_real', 'validation', 'i1k_i21k')
c.evals.teacher_i1k_real.pp_fn = pp_eval_prof + pp_label_i1k.format(lbl='real_label')
# TODO: add objectnet.
####
# Combined evals
def get_dist(split, s):
return dict(
type='proj.distill.distance',
pred=f'student_seqhw={s}_prof',
data=dict(name='imagenet2012', split=mksplit(split)),
pp_fn=pp_eval_both + '|keep("image", "prof")',
log_percent=0.05,
distances=({'kind': 'kl'}, {'kind': 'logsoftmax_euclidean'},
{'kind': 'agree', 'k': 1}, {'kind': 'agree', 'k': 5}),
)
for s in c.flexi.seqhw.v:
c.evals[f'dist_minitrain_{s:02d}'] = get_dist('full[51_200:76_800]', s)
c.evals[f'dist_val_{s:02d}'] = get_dist('full[25_600:51_200]', s)
# Few-shot evaluators not added for overkill reasons for now.
return c
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Trains CLIP with Pixels Only (CLIPPO), https://arxiv.org/abs/2212.08045
IMPORTANT NOTE: This config uses coco_captions by default for demonstration
purposes since the TFDS catalog does not provide any large image/alt-text data
set; the training will not produce a model with useful accuracy. Please
replace the data set below (marked by a comment) with an appropriate image/
alt-text data set wrapped in TFDS (for example LAION-400M) and run the config
with the suffix `:test_with_coco=False` to train on your data set. Refer to
the following guide to build a TFDS wrapper for your favorite image/alt-text
data set:
https://www.tensorflow.org/datasets/add_dataset
Also note that evaluation on ImageNet requires manual TFDS setup, see
https://github.com/google-research/big_vision#preparing-tfds-data
Example training:
big_vision.trainers.proj.image_text.contrastive \
--config big_vision/configs/proj/clippo/train_clippo.py \
--workdir gs://[your_bucket]/big_vision/`date '+%Y-%m-%d_%H%M'`
"""
import big_vision.configs.common as bvcc
from big_vision.configs.common_fewshot import get_fewshot_lsr
from big_vision.configs.proj.image_text import common
from ml_collections import ConfigDict
def get_config(arg=None):
"""The base configuration."""
arg = bvcc.parse_arg(
arg, res=224, runlocal=False, variant='B/16',
test_with_coco=True, i1k_eval=False)
config = ConfigDict()
config.input = {}
if arg.test_with_coco:
# Use COCO Captions for sanity-checking
config.input.data = dict(name='coco_captions', split='train')
val_data = dict(config.input.data)
val_data['split'] = 'val'
config.input.batch_size = 4000 if not arg.runlocal else 32
config.input.shuffle_buffer_size = 50_000 if not arg.runlocal else 50
config.total_steps = 400 if not arg.runlocal else 10
else:
# Please add your favorite image/alt-text dataset here
config.input.data = None
val_data = None
assert config.input.data is not None and val_data is not None, (
config.input.data, val_data)
# The value in the paper is 10 * 1024, which requires 128 TPUv3 cores or a
# memory optimized ViT implementation when running on 128 TPUv2 cores.
config.input.batch_size = 8 * 1024 if not arg.runlocal else 32
config.input.shuffle_buffer_size = 250_000 if not arg.runlocal else 50
config.total_steps = 100_000 if not arg.runlocal else 10
def tokenizer(inkey, outkey='labels'):
return (f'render_unifont('
f'inkey="{inkey}", '
f'outkey="{outkey}", '
f'image_size={arg.res}, '
f'lower=True, '
f'font_size=16, '
f'text_brightness=0, '
f'background_brightness=127)|'
f'value_range(-1, 1, inkey="{outkey}", outkey="{outkey}")')
pp_image = f'decode|resize({arg.res})|value_range(-1,1)'
if arg.test_with_coco:
# Train with augmentation when sanity-checking
pp_image_aug = (
f'decode|resize({arg.res})|flip_lr|randaug(2,10)|value_range(-1,1)')
config.input.pp = pp_eval = (
f'{pp_image_aug}|flatten|{tokenizer("captions/text")}|'
f'keep("image", "labels")')
else:
config.input.pp = pp_eval = (
f'{pp_image}|flatten|{tokenizer("text")}|keep("image", "labels")')
config.pp_modules = [
'ops_general', 'ops_image', 'ops_text', 'proj.clippo.pp_ops']
config.log_training_steps = 50
config.ckpt_steps = 1000
config.keep_ckpt_steps = 5000
config.loss_use_global_batch = True
# Define the model
config.model_name = 'proj.clippo.one_tower'
config.model = ConfigDict()
config.model.image_model = 'vit'
config.model.image = ConfigDict({
'variant': arg.variant,
'pool_type': 'map',
'head_zeroinit': False,
})
if arg.test_with_coco:
# Initialize with ImageNet21k pretrained checkpoint for sanity-checking
assert arg.variant == 'B/16', arg.variant
config.model_init = {'image': 'howto-i21k-B/16'}
config.model_load = {}
config.model_load['img_load_kw'] = {
'dont_load': ['^head/.*', '^MAPHead_0/.*', 'cls']}
config.model.temperature_init = 10.0
config.model.out_dim = 768
# Define the optimizer
config.optax_name = 'big_vision.scale_by_adafactor'
config.grad_clip_norm = 1.0
if arg.test_with_coco:
# Short schedule for sanity-checking
config.lr = 0.0001
config.wd = 0.0003
config.schedule = dict(decay_type='rsqrt',
timescale=100,
warmup_steps=100 if not arg.runlocal else 5,
cooldown_steps=100 if not arg.runlocal else 5)
else:
config.lr = 0.001
config.wd = 0.0001
config.schedule = dict(decay_type='rsqrt',
timescale=10_000,
warmup_steps=10_000 if not arg.runlocal else 5,
cooldown_steps=10_000 if not arg.runlocal else 5)
# Eval section (Both few-shot and zero-shot)
eval_common = dict(
type='proj.image_text.contrastive',
use_global_batch=config.loss_use_global_batch,
log_steps=1000 if not arg.runlocal else 5,
)
config.evals = {}
sub = '[:4]' if arg.runlocal else ''
config.evals.val = {
**eval_common,
'data': val_data,
'pp_fn': pp_eval,
}
config.evals.coco = {
**eval_common,
'data': dict(name='coco_captions', split=f'val{sub}'),
'pp_fn': (
f'{pp_image}|flatten|{tokenizer("captions/text")}|'
f'keep("image", "labels")'),
}
if arg.i1k_eval:
# Requires manual download, see
# https://github.com/google-research/big_vision#preparing-tfds-data
config.evals.imagenet = {
**eval_common,
'data': dict(name='imagenet2012', split=f'validation{sub}'),
'pp_fn': (
f'{pp_image}|clip_i1k_label_names|'
f'{tokenizer("labels")}|keep("image", "labels")'),
}
config.evals.disclf = dict(
type='proj.image_text.discriminative_classifier',
pp_txt=tokenizer('texts', 'labels'),
prefix='z/0shot/',
log_steps=5_000 if not arg.runlocal else 5)
config.evals.retrieval_coco = common.get_coco(
pp_img=f'resize({arg.res})|value_range(-1, 1)',
pp_txt=tokenizer('texts'),
log_steps=5_000 if not arg.runlocal else 5,
)
# Few-shot metrics
config.evals.fewshot = get_fewshot_lsr()
config.evals.fewshot.log_steps = 5_000 if not arg.runlocal else 5
config.evals.fewshot.representation_layer = 'img/pre_logits'
config.seed = 0
return config
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Pre-train ViT-g (1B params) on JFT-3B as in https://arxiv.org/abs/2106.04560
To train ViT-G (2B params), simply update the following single line:
`config.model.variant = 'G/14'`
The code is released for reference purposes.
One can test the code using public ImageNet-1k or ImageNet-21k dataset.
big_vision.train \
--config big_vision/configs/proj/scaling_laws/train_vit_g.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'`
"""
from big_vision.configs.common_fewshot import get_fewshot_lsr
import ml_collections as mlc
def get_config():
"""Rocket config."""
config = mlc.ConfigDict()
config.dataset = 'jft_3b'
config.val_split = 'val'
config.train_split = 'train'
config.num_classes = 29_593
config.init_head_bias = -10.0
# Fits 32 images per TPUv3 core with ViT-g/14.
config.batch_size = 4096*4
pp_common = '|value_range(-1, 1)'
pp_common += f'|onehot({config.num_classes})'
pp_common += '|keep("image", "labels")'
config.pp_train = 'inception_crop(224)|flip_lr' + pp_common
config.pp_eval = 'resize_small(256)|central_crop(224)' + pp_common
config.shuffle_buffer_size = 250_000 # Per host, so small-ish is ok.
config.log_training_steps = 50
config.log_eval_steps = 1000
# NOTE: eval is very fast O(seconds) so it's fine to run it often.
config.ckpt_steps = 1000
config.keep_ckpt_steps = 10_000
config.prefetch_to_device = 1
config.trial = 0
# Model section
config.model_name = 'vit'
config.model = mlc.ConfigDict()
config.model.variant = 'g/14'
config.model.pool_type = 'map'
# Optimizer section
config.optax_name = 'big_vision.scale_by_adafactor'
config.grad_clip_norm = 1.0
config.lr = 8e-4
config.wd = 0.03 * 8e-4
config.wd_mults = [
('.*head/kernel', 100.0),
('.*/kernel', 1.0),
]
config.schedule = dict(
decay_type='rsqrt', timescale=10_000, warmup_steps=10_000,
cooldown_steps=50_000)
config.total_steps = 1_000_000
# Few-shot eval section
config.evals = {}
config.evals.fewshot = dict(log_steps=10_000, **get_fewshot_lsr())
return config
|
# Copyright 2023 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Object detection reward from "Tuning computer vision models with task rewards" (https://arxiv.org/abs/2302.08242).
The `reward_fn` computes the reward for a batch of predictions and ground truth
annotations. When using it to optimize a model that outputs a prediction as a
sequence of tokens like [y0, x0, Y0, X0, class0, confidence0, y1, x1, Y1, ...]
the training loop may look like:
```
# Settings used in the paper.
config.max_level = 1000 # Coordinates are discretized into 1000 buckets.
config.max_conf = 2 # Two tokens are reserved to represent confidence.
config.num_cls = 80 # Number of classes in COCO.
config.nms_w = 0.3 # Weight for duplicate instances.
config.cls_smooth = 0.05 # Adjust the classes weights based on their frequency.
config.reward_thr = (0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95)
config.correct_thr = 0.5 # Learn the IoU when matching with threshold=0.5.
config.conf_w = 0.3 # Weight for the confidence loss.
# 1) Sample N outputs for each input and compute rewards, use one sample to
# optimize and others to compute a reward baseline.
sample_seqs = sample_fn(params, images, num_samples)
sample_rewards, aux = reward_fn(sample_seqs, labels, config)
labels = sample_seqs[:, 0, ...]
rewards = sample_rewards[:, 0]
match_iou = aux["match_iou"][:, 0]
baselines = (jnp.sum(sample_rewards, axis=-1) - rewards) / (num_samples - 1)
# 2) Optimizize the model. By using REINFORCE to adjust the likelihood of the
# sequence based on the reward and with supervision to teach the model to
# predict the expected IoU of each box in its own samples.
def loss_fn(params):
logits = model.apply(params, images, labels, train=True, rngs=rngs)
logits_softmax = jax.nn.log_softmax(logits)
# Use reinforce to optimize the expected reward for the whole sequence.
seq_rewards = (rewards - baselines)
# Note: consider improve this code to skip this loss for confidence tokens.
# The paper did not do it due to a bug (and also does not seem to matter).
target = jax.nn.one_hot(labels, logits.shape[-1]) * seq_rewards[:, None, None]
loss_reward = -jnp.sum(target * logits_softmax, axis=-1)
# Use supervision loss to tune the confidence tokens to predict IoU:
# - (1.0, 0.0, 0.0, ...) -> for padded boxes.
# - (0.0, 1-iou, iou, ...) -> for sampled boxes.
conf0 = (labels[:, 5::6] == 0)
conf1 = (labels[:, 5::6] > 0) * (1.0 - match_iou)
conf2 = (labels[:, 5::6] > 0) * match_iou
target_conf = jnp.stack([conf0, conf1, conf2], axis=-1)
logits_conf = logits_softmax[:, 5::6, :3]
loss_conf = -jnp.sum(target_conf * logits_conf, axis=-1)
loss = jnp.mean(loss_reward) + config.conf_w * jnp.mean(loss_conf)
return loss
```
"""
import einops
import jax
import jax.numpy as jnp
xmap = jax.experimental.maps.xmap
# Frequency of COCO object detection classes as observed in the training set.
# pylint: disable=bad-whitespace,bad-continuation
CLS_COUNTS = [
262465, 7113, 43867, 8725, 5135, 6069, 4571, 9973, 10759,
12884, 1865, 1983, 1285, 9838, 10806, 4768, 5508, 6587,
9509, 8147, 5513, 1294, 5303, 5131, 8720, 11431, 12354,
6496, 6192, 2682, 6646, 2685, 6347, 9076, 3276, 3747,
5543, 6126, 4812, 24342, 7913, 20650, 5479, 7770, 6165,
14358, 9458, 5851, 4373, 6399, 7308, 7852, 2918, 5821,
7179, 6353, 38491, 5779, 8652, 4192, 15714, 4157, 5805,
4970, 2262, 5703, 2855, 6434, 1673, 3334, 225, 5610,
2637, 24715, 6334, 6613, 1481, 4793, 198, 1954
]
# pylint: enable=bad-whitespace,bad-continuation
def seq2box(seq, max_level, max_conf, num_cls):
"""Extract boxes encoded as sequences."""
# Reshape to instances of boxes
dim_per_box = 6
seq_len = seq.shape[-1]
seq = seq[..., :(seq_len - seq_len % dim_per_box)]
seq = einops.rearrange(seq, "... (n d) -> ... n d", d=dim_per_box)
# Unpack box fields
boxes, labels, confs = seq[..., 0:4], seq[..., 4], seq[..., 5]
boxes = boxes - max_conf - 1
labels = labels - max_conf - 1 - max_level - 1
boxes = jnp.clip(boxes, 0, max_level) / max_level
labels = jnp.clip(labels, 0, num_cls - 1)
confs = jnp.clip(confs, 0, max_conf)
return boxes, labels, confs
def iou_fn(box1, box2):
"""Compute IoU of two boxes."""
ymin1, xmin1, ymax1, xmax1 = box1
ymin2, xmin2, ymax2, xmax2 = box2
a1 = jnp.abs((ymax1 - ymin1) * (xmax1 - xmin1))
a2 = jnp.abs((ymax2 - ymin2) * (xmax2 - xmin2))
yl = jnp.maximum(ymin1, ymin2)
yr = jnp.minimum(ymax1, ymax2)
yi = jnp.maximum(0, yr - yl)
xl = jnp.maximum(xmin1, xmin2)
xr = jnp.minimum(xmax1, xmax2)
xi = jnp.maximum(0, xr - xl)
inter = xi * yi
return inter / (a1 + a2 - inter + 1e-9)
iou_fn_batched = xmap(iou_fn,
in_axes=({0: "batch1"}, {0: "batch2"}),
out_axes={0: "batch1", 1: "batch2"})
def _reward_fn_thr(seq_pred, seq_gt,
thr, nms_w, max_level, max_conf, num_cls, cls_smooth):
"""Compute detection reward function for a given IoU threshold."""
# Weight matches of each label inversely proportional to the percentage of
# GT instances with such label in the whole train dataset. Additionally
# smooth out the observed distribution.
cls_counts = jnp.array(CLS_COUNTS)
weights = 1.0 / (cls_counts + cls_smooth*jnp.sum(cls_counts))
weights = num_cls * weights / jnp.sum(weights)
boxes_pred, labels_pred, confs_pred = seq2box(
seq_pred, max_level, max_conf, num_cls)
boxes_gt, labels_gt, confs_gt = seq2box(
seq_gt, max_level, max_conf, num_cls)
# Compute IoU matrix: Predictions X GT
iou = iou_fn_batched(boxes_pred, boxes_gt)
# IoU thr
iou = jnp.where(iou > thr, iou, 0.0)
# EOS mask
confs_mask = (confs_pred[:, None] > 0) * (confs_gt[None, :] > 0)
iou = confs_mask * iou
# Label mask
label_mask = labels_pred[:, None] == labels_gt[None, :]
iou = label_mask * iou
# Each prediction is matched to a single box
single_match_mask = jax.nn.one_hot(jnp.argmax(iou, axis=1), iou.shape[1])
iou = iou * single_match_mask
# Pred. boxes indicators
correct = jnp.any(iou > 0.0, axis=1).astype("int32") + 1
correct = jnp.where(confs_pred > 0, correct, 0)
# For each GT box find best match
matches_idx = jnp.argmax(iou, axis=0)
matches_iou = jnp.take_along_axis(iou, matches_idx[None], axis=0)[0]
matches_idx = jnp.where(matches_iou > 0.0, matches_idx, -1)
match_reward = jnp.sum((matches_idx >= 0) * weights[labels_gt][None, :])
# Compute duplicate penalty (aka NMS).
matches_mask = jax.nn.one_hot(matches_idx, iou.shape[0], axis=0)
nms_penalty = jnp.sum(
(iou > 0.0) * (1 - matches_mask) * weights[labels_pred][:, None])
match_iou = jnp.sum(iou, axis=1)
return {
"reward": (match_reward - nms_w * nms_penalty),
"num_matches": jnp.sum(matches_idx >= 0),
"nms_penalty": nms_penalty,
"correct": correct,
"match_iou": match_iou,
}
def reward_fn(seqs_pred, seqs_gt, config):
"""Total reward."""
result = {}
thrs = config.reward_thr
correct_thr = config.correct_thr
r_keys = ["reward", "num_matches", "nms_penalty"]
for thr in thrs:
rewards = xmap(
lambda pred, gt: _reward_fn_thr(
pred, gt,
thr, config.nms_w, config.max_level, # pylint: disable=cell-var-from-loop
config.max_conf, config.num_cls, config.cls_smooth),
in_axes=({0: "batch", 1: "samples"}, {0: "batch"}),
out_axes={0: "batch", 1: "samples"})(seqs_pred, seqs_gt)
result = {**result, **{f"{k}-{thr:0.1f}": rewards[k]
for k in r_keys}}
if thr == correct_thr:
correct = rewards["correct"]
match_iou = rewards["match_iou"]
result = {
**result,
**{k: jnp.mean(
jnp.array([result[f"{k}-{thr:0.1f}"] for thr in thrs]), axis=0)
for k in r_keys}
}
return result["reward"], {
"result": result,
"correct": correct,
"match_iou": match_iou,
}
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Distilling BiT-R152x2 into BiT-R50x1 on Food101/Sun397 as in https://arxiv.org/abs/2106.05237
While many epochs are required, this is a small dataset, and thus overall it
is still fast and possible to run on the relatively small v3-8TPUs (or GPUs).
This configuration contains the recommended settings from Fig3/Tab4 of the
paper, which can be selected via the fast/medium/long config argument.
(best settings were selected on a 10% minival)
For Food101:
- The `fast` variant takes ~45min on a v2-8 TPU.
Example logs at gs://big_vision/distill/bit_food_fast_06-19_0547/big_vision_metrics.txt
Example logs at gs://big_vision/distill/bit_sun_fast_06-20_1839/big_vision_metrics.txt
- The `long` variant takes ~14h on a v3-8 TPU.
Example logs at gs://big_vision/distill/bit_food_long_06-19_0614/big_vision_metrics.txt
Example logs at gs://big_vision/distill/bit_sun_long_06-20_1912/big_vision_metrics.txt
big_vision.trainers.proj.distill.distill \
--config big_vision/configs/proj/distill/bigsweep_food_sun.py:data=food,variant=fast \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
"""
import big_vision.configs.common as bvcc
import big_vision.configs.proj.distill.common as cd
import ml_collections as mlc
H, L = 160, 128
NCLS = dict(food=101, sun=397)
def get_config(arg=None):
"""Config for massive hypothesis-test on pet."""
arg = bvcc.parse_arg(arg, runlocal=False, data='food', variant='medium', crop='inception_crop(128)')
config = mlc.ConfigDict()
config.input = {}
config.input.data = dict(
name=dict(food='food101', sun='sun397')[arg.data],
split=dict(food='train[:90%]', sun='train')[arg.data],
)
config.input.batch_size = 512
config.input.cache_raw = True
config.input.shuffle_buffer_size = 50_000
config.prefetch_to_device = 4
config.num_classes = NCLS[arg.data]
config.total_epochs = {'fast': 100, 'medium': 1000, 'long': 3000}[arg.variant]
config.log_training_steps = 50
config.ckpt_steps = 2500
# Model section
config.student_name = 'bit_paper'
config.student = dict(depth=50, width=1)
config.teachers = ['prof_m']
config.prof_m_name = 'bit_paper'
config.prof_m_init = cd.inits[f'BiT-M R152x2 {arg.data} rc128']
config.prof_m = dict(depth=152, width=2)
# Preprocessing pipeline for student & tacher.
pp_common = (
'|value_range(-1, 1)'
f'|onehot({config.num_classes}, key="label", key_result="labels")'
'|keep("image", "labels")'
)
config.input.pp = f'decode|{arg.crop}|flip_lr' + pp_common
ppv = 'decode|resize_small(160)|central_crop(128)' + pp_common
config.mixup = dict(p=1.0, n=2)
# Distillation settings
config.distance = 'kl'
config.distance_kw = dict(t={
'food': {'fast': 10., 'medium': 10., 'long': 5.},
'sun': {'fast': 10., 'medium': 10., 'long': 10.},
}[arg.data][arg.variant])
# Optimizer section
config.grad_clip_norm = 1.0
config.optax_name = 'scale_by_adam'
config.optax = dict(mu_dtype='bfloat16')
config.lr = {
'food': {'fast': 0.01, 'medium': 0.001, 'long': 0.01},
'sun': {'fast': 0.01, 'medium': 0.001, 'long': 0.01},
}[arg.data][arg.variant]
config.wd = {
'food': {'fast': 1e-3, 'medium': 3e-4, 'long': 1e-4},
'sun': {'fast': 1e-3, 'medium': 1e-4, 'long': 3e-5},
}[arg.data][arg.variant]
config.schedule = dict(warmup_steps=1500, decay_type='cosine')
config.optim_name = 'adam_hp'
# Eval section
minitrain_split = 'train[:1024]' if not arg.runlocal else 'train[:16]'
if arg.data == 'food':
val_split = 'train[90%:]' if not arg.runlocal else 'train[:16]'
test_split = 'validation' if not arg.runlocal else 'test[:16]'
elif arg.data == 'sun':
val_split = 'validation' if not arg.runlocal else 'validation[:16]'
test_split = 'test' if not arg.runlocal else 'test[:16]'
def get_eval(split):
return dict(
type='classification',
pred='student_fwd',
data=dict(name=config.input.data.name, split=split),
pp_fn=ppv,
loss_name='softmax_xent',
log_steps=500,
)
config.evals = {}
config.evals.student_train = get_eval(minitrain_split)
config.evals.student_val = get_eval(val_split)
config.evals.student_test = get_eval(test_split)
# Teacher is fixed, so rare evals.
teacher = dict(log_steps=100_000, pred='prof_m_fwd')
config.evals.teacher_train = {**config.evals.student_train, **teacher}
config.evals.teacher_val = {**config.evals.student_val, **teacher}
config.evals.teacher_test = {**config.evals.student_test, **teacher}
# Could in principle also look at agreement on other datasets!
def get_dist(split):
return dict(
type='proj.distill.distance',
pred='student_prof_m_fwd',
data=dict(name=config.input.data.name, split=split),
pp_fn=ppv + '|keep("image")',
log_steps=1000,
distances=({'kind': 'kl'}, {'kind': 'euclidean'},
{'kind': 'agree', 'k': 1}, {'kind': 'agree', 'k': 5}),
)
config.evals.dist_train = get_dist(minitrain_split)
config.evals.dist_val = get_dist(val_split)
config.evals.dist_test = get_dist(test_split)
# Make a few things much smaller for quick local debugging testruns.
if arg.runlocal:
config.input.shuffle_buffer_size = 10
config.input.batch_size = 8
return config
def get_hyper(hyper):
"""Hyper sweep."""
# TODO: update, similar to flowers_pet sweep.
# By default, not running the MASSIVE sweep, just the recommended setting
# across durations. However, code for sweep is left for reference/convenience.
return hyper.zipit([
hyper.sweep('config.total_epochs', [100, 1_000]),
hyper.sweep('config.mixup.p', [0.0, 1.0]),
hyper.sweep('config.weight_decay', [1e-3, 1e-5]),
])
# pylint: disable=unreachable
def fix(**kw):
return hyper.product([hyper.fixed(f'config.{k}', v, length=1)
for k, v in kw.items()])
def setting(p, l, m, crop, pp_end=None, **extra):
pp_end = pp_end or (
f'|value_range(-1, 1, key="image")'
f'|onehot({NCLS}, key="label", key_result="labels")'
f'|keep("image", "labels")'
)
return hyper.product([
fix(**{'mixup.p': p}),
fix(l=l, m=m, crop=crop),
fix(pp_train=f'decode|{crop}|flip_lr|randaug({l},{m})' + pp_end),
fix(**extra)
])
# Mixup, Layers and Mag in randaug.
plm = [(0.0, 0, 0), (0.1, 0, 0), (0.5, 0, 0), (1.0, 0, 0)]
return hyper.product([
hyper.sweep('config.total_epochs', [100, 1000, 3000]),
hyper.sweep('config.lr.base', [0.001, 0.003, 0.01]),
hyper.sweep('config.distance_kw.t', [1.0, 2.0, 5.0, 10.0]),
hyper.sweep('config.weight_decay', [1e-5, 3e-5, 1e-4, 3e-4, 1e-3]),
hyper.chainit(
[setting(p=p, l=l, m=m,
crop=(f'resize({H})'
f'|inception_crop({L}, outkey="student")'
f'|central_crop({L}, outkey="teacher")'),
pp_end=(
f'|value_range(-1, 1, key="student")'
f'|value_range(-1, 1, key="teacher")'
f'|onehot({NCLS}, key="label", key_result="labels")'
f'|keep("student", "teacher", "labels")'))
for p, l, m in plm] +
[setting(p=p, l=l, m=m, crop=f'inception_crop({L})') for
p, l, m in plm],
)
])
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Distilling BiT-R152x2 into BiT-R50x1 on Flowers/Pet as in https://arxiv.org/abs/2106.05237
While many epochs are required, this is a small dataset, and thus overall it
is still fast and possible to run on the relatively small v3-8TPUs (or GPUs).
This configuration contains the recommended settings from Fig3/Tab4 of the
paper, which can be selected via the fast/medium/long config argument.
(best settings were selected on a 10% minival)
For Flowers:
- The `fast` variant takes ~1h10m on a v2-8 TPU.
Example logs at gs://big_vision/distill/bit_flowers_fast_06-18_2008/big_vision_metrics.txt
- The `long` variant takes ~25h on a v3-32 TPU.
Example logs at gs://big_vision/distill/bit_flowers_long_06-19_0524/big_vision_metrics.txt
For Pet:
- The `fast` variant takes ~28min on a v2-8 TPU.
Example logs at gs://big_vision/distill/bit_pet_fast_06-16_2338/big_vision_metrics.txt
- The `long` variant takes ~11h on a v2-8 and ~8h on a v3-32.
Example logs at gs://big_vision/distill/bit_pet_long_06-17_0050/big_vision_metrics.txt
big_vision.trainers.proj.distill.distill \
--config big_vision/configs/proj/distill/bigsweep_flowers_pet.py:data=flowers,variant=fast \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
"""
import big_vision.configs.common as bvcc
import big_vision.configs.proj.distill.common as cd
import ml_collections as mlc
NCLS = dict(flowers=102, pet=37)
def get_config(arg=None):
"""Config for massive hypothesis-test on pet."""
arg = bvcc.parse_arg(arg, runlocal=False, data='flowers', variant='medium', crop='inception_crop(128)')
config = mlc.ConfigDict()
config.input = {}
config.input.data = dict(
name=dict(flowers='oxford_flowers102', pet='oxford_iiit_pet')[arg.data],
split=dict(flowers='train', pet='train[:90%]')[arg.data],
)
config.input.batch_size = 512
config.input.cache_raw = True
config.input.shuffle_buffer_size = 50_000
config.prefetch_to_device = 4
config.num_classes = NCLS[arg.data]
config.total_epochs = {
'flowers': {'fast': 10_000, 'medium': 100_000, 'long': 1_000_000},
'pet': {'fast': 1000, 'medium': 3000, 'long': 30_000},
}[arg.data][arg.variant]
config.log_training_steps = 100
config.ckpt_steps = 2500
# Model section
config.student_name = 'bit_paper'
config.student = dict(depth=50, width=1)
config.teachers = ['prof_m']
config.prof_m_name = 'bit_paper'
config.prof_m_init = cd.inits[f'BiT-M R152x2 {arg.data} rc128']
config.prof_m = dict(depth=152, width=2)
# Preprocessing pipeline for student & tacher.
pp_common = (
'|value_range(-1, 1)'
f'|onehot({config.num_classes}, key="label", key_result="labels")'
'|keep("image", "labels")'
)
config.input.pp = f'decode|{arg.crop}|flip_lr' + pp_common
ppv = 'decode|resize_small(160)|central_crop(128)' + pp_common
config.mixup = dict(p=1.0, n=2)
# Distillation settings
config.distance = 'kl'
config.distance_kw = dict(t={
'flowers': {'fast': 10., 'medium': 1., 'long': 1.},
'pet': {'fast': 5., 'medium': 10., 'long': 2.},
}[arg.data][arg.variant])
# Optimizer section
config.grad_clip_norm = 1.0
config.optax_name = 'scale_by_adam'
config.optax = dict(mu_dtype='bfloat16')
config.lr = {
'flowers': {'fast': 0.003, 'medium': 0.001, 'long': 0.0003},
'pet': {'fast': 0.01, 'medium': 0.003, 'long': 0.003},
}[arg.data][arg.variant]
config.wd = {
'flowers': {'fast': 3e-4, 'medium': 1e-4, 'long': 1e-5},
'pet': {'fast': 1e-3, 'medium': 3e-4, 'long': 1e-5},
}[arg.data][arg.variant]
config.schedule = dict(warmup_steps=1500, decay_type='cosine')
config.optim_name = 'adam_hp'
# Eval section
minitrain_split = 'train[:512]' if not arg.runlocal else 'train[:16]'
if arg.data == 'flowers':
val_split = 'validation' if not arg.runlocal else 'validation[:16]'
test_split = 'test' if not arg.runlocal else 'test[:16]'
elif arg.data == 'pet':
val_split = 'train[90%:]' if not arg.runlocal else 'train[:16]'
test_split = 'test' if not arg.runlocal else 'test[:16]'
def get_eval(split):
return dict(
type='classification',
pred='student_fwd',
data=dict(name=config.input.data.name, split=split),
pp_fn=ppv,
loss_name='softmax_xent',
log_steps=500,
)
config.evals = {}
config.evals.student_train = get_eval(minitrain_split)
config.evals.student_val = get_eval(val_split)
config.evals.student_test = get_eval(test_split)
# Teacher is fixed, so rare evals.
teacher = dict(log_steps=100_000, pred='prof_m_fwd')
config.evals.teacher_train = {**config.evals.student_train, **teacher}
config.evals.teacher_val = {**config.evals.student_val, **teacher}
config.evals.teacher_test = {**config.evals.student_test, **teacher}
# Could in principle also look at agreement on other datasets!
def get_dist(split):
return dict(
type='proj.distill.distance',
pred='student_prof_m_fwd',
data=dict(name=config.input.data.name, split=split),
pp_fn=ppv + '|keep("image")',
log_steps=1000,
distances=({'kind': 'kl'}, {'kind': 'euclidean'},
{'kind': 'agree', 'k': 1}, {'kind': 'agree', 'k': 5}),
)
config.evals.dist_train = get_dist(minitrain_split)
config.evals.dist_val = get_dist(val_split)
config.evals.dist_test = get_dist(test_split)
# Make a few things much smaller for quick local debugging testruns.
if arg.runlocal:
config.input.shuffle_buffer_size = 10
config.input.batch_size = 8
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Most common teachers for distillation."""
# pylint: disable=line-too-long
inits = { # pylint: disable=duplicate-key Internally, we override some paths for convenience.
'BiT-M R152x2 imagenet2012 ic224': 'gs://bit_models/distill/R152x2_T_224.npz',
'BiT-M R152x2 imagenet2012 rc384': 'gs://bit_models/distill/R152x2_T_384.npz',
'BiT-M R152x2 flowers rc128': 'gs://bit_models/distill/R152x2_T_flowers128.npz',
'BiT-M R152x2 pet rc128': 'gs://bit_models/distill/R152x2_T_pet128.npz',
'BiT-M R152x2 food rc128': 'gs://bit_models/distill/R152x2_T_food128.npz',
'BiT-M R152x2 sun rc128': 'gs://bit_models/distill/R152x2_T_sun128.npz',
}
# pylint: enable=line-too-long
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Distilling BiT-R152x2 into BiT-R50x1 on ILSVRC-2012 as in https://arxiv.org/abs/2106.05237
Note that as per paper title, good results require many epochs and thus
a lot of _patience_. For experimentation/exploration, consider
using the smaller datasets.
300ep take about 15h on a v3-32 TPU, an example log is available at:
Example logs at gs://big_vision/distill/bit_i1k_300ep_06-16/big_vision_metrics.txt
big_vision.trainers.proj.distill.distill \
--config big_vision/configs/proj/distill/bit_i1k.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'` \
--config.total_epochs 1200
"""
import big_vision.configs.common as bvcc
from big_vision.configs.common_fewshot import get_fewshot_lsr
import big_vision.configs.proj.distill.common as cd
import ml_collections as mlc
def get_config(arg=None):
"""Config for distilling on ImageNet."""
arg = bvcc.parse_arg(arg, runlocal=False)
config = mlc.ConfigDict()
config.input = {}
config.input.data = dict(name='imagenet2012', split='train[:98%]')
config.input.batch_size = 4096
config.input.shuffle_buffer_size = 250_000
config.num_classes = 1000
config.total_epochs = 1200 # A good middle-ground
config.log_training_steps = 50
config.ckpt_steps = 1000
config.keep_ckpt_steps = 20000
# Model section
config.student_name = 'bit_paper'
config.student = dict(depth=50, width=1)
config.teachers = ['prof_m'] # You could even add multiple.
# TODO: use public checkpoint name.
config.prof_m_name = 'bit_paper'
config.prof_m_init = cd.inits['BiT-M R152x2 imagenet2012 ic224']
config.prof_m = dict(depth=152, width=2)
pp_common = (
'|value_range(-1, 1)'
'|onehot(1000, key="{lbl}", key_result="labels")'
'|keep("image", "labels")'
)
config.input.pp = (
'decode_jpeg_and_inception_crop(224)|flip_lr' +
pp_common.format(lbl='label')
)
ppv = 'decode|resize_small(256)|central_crop(224)' + pp_common
config.mixup = dict(p=1.0, n=2)
# Distillation settings
config.distance = 'kl'
config.distance_kw = dict(t=1.0)
# Optimizer section
config.grad_clip_norm = 1.0
config.optax_name = 'scale_by_adam'
config.optax = dict(mu_dtype='bfloat16')
config.lr = 0.03
config.wd = 0.0003
config.schedule = dict(warmup_steps=5000, decay_type='cosine')
# Eval section
minitrain_split = 'train[:2%]' if not arg.runlocal else 'train[:16]'
minival_split = 'train[99%:]' if not arg.runlocal else 'train[:16]'
val_split = 'validation' if not arg.runlocal else 'validation[:16]'
real_split = 'validation' if not arg.runlocal else 'validation[:16]'
v2_split = 'test' if not arg.runlocal else 'test[:16]'
def get_eval(split, dataset='imagenet2012'):
return dict(
type='classification',
pred='student_fwd',
data=dict(name=dataset, split=split),
pp_fn=ppv.format(lbl='label'),
loss_name='softmax_xent',
log_steps=1000,
)
config.evals = {}
config.evals.student_train = get_eval(minitrain_split)
config.evals.student_minival = get_eval(minival_split)
config.evals.student_val = get_eval(val_split)
config.evals.student_v2 = get_eval(v2_split, dataset='imagenet_v2')
config.evals.student_real = get_eval(real_split, dataset='imagenet2012_real')
config.evals.student_real.pp_fn = ppv.format(lbl='real_label')
config.evals.student_fewshot = get_fewshot_lsr(runlocal=arg.runlocal)
config.evals.student_fewshot.pred = 'student_fwd'
config.evals.student_fewshot.log_steps = 10_000
teacher_eval = dict(
log_steps=100_000, # Teacher is fixed, so rare evals.
pred='prof_m_fwd',
)
config.evals.teacher_train = {**config.evals.student_train, **teacher_eval}
config.evals.teacher_minival = {**config.evals.student_minival, **teacher_eval}
config.evals.teacher_val = {**config.evals.student_val, **teacher_eval}
config.evals.teacher_v2 = {**config.evals.student_v2, **teacher_eval}
config.evals.teacher_real = {**config.evals.student_real, **teacher_eval}
config.evals.teacher_fewshot = {**config.evals.student_fewshot, **teacher_eval}
config.evals.teacher_fewshot.prefix = 'z_teacher/'
# Could in principle also look at agreement on other datasets!
def get_dist(split, dataset='imagenet2012'):
return dict(
type='proj.distill.distance',
pred='student_prof_m_fwd',
data=dict(name=dataset, split=split),
pp_fn=ppv.format(lbl='label') + '|keep("image")',
log_steps=1000,
distances=({'kind': 'kl'}, {'kind': 'euclidean'},
{'kind': 'agree', 'k': 1}, {'kind': 'agree', 'k': 5}),
)
config.evals.dist_train = get_dist(minitrain_split)
config.evals.dist_minival = get_dist(minival_split)
config.evals.dist_val = get_dist(val_split)
config.evals.dist_v2 = get_dist(v2_split, dataset='imagenet_v2')
# NOTE: CKA evaluator does not work with batch padding, so the size of the
# split must be a multiple of the batch size.
def get_cka(split):
return dict(
type='proj.distill.cka',
pred='student_prof_m_fwd',
data=dict(name='imagenet2012', split=split),
pp_fn=ppv.format(lbl='label') + '|keep("image")',
log_steps=1000,
)
config.evals.cka_train = get_cka('train[:24576]' if not arg.runlocal else 'train[:16]')
config.evals.cka_minival = get_cka('train[-24576:]' if not arg.runlocal else 'train[:16]')
config.evals.cka_val = get_cka('validation[:49152]' if not arg.runlocal else 'validation[:16]')
# Make a few things much smaller for quick local debugging testruns.
if arg.runlocal:
config.input.shuffle_buffer_size = 10
config.input.batch_size = 8
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for training a colorization VQ-VAE on imagenet2012.
"""
import itertools
import big_vision.configs.common as bvcc
import ml_collections as mlc
def get_config(arg='res=512,patch_size=16'):
"""A config for training a UViM stage I model for the colorization task."""
arg = bvcc.parse_arg(arg, res=512, patch_size=16,
runlocal=False, singlehost=False)
config = mlc.ConfigDict()
config.task = 'proj.uvim.colorization_task'
config.input = {}
config.input.data = dict(name='imagenet2012', split='train[4096:]')
config.input.batch_size = 1024
config.input.shuffle_buffer_size = 25_000
config.total_epochs = 100
config.input.pp = (
f'decode_jpeg_and_inception_crop({arg.res})'
f'|flip_lr'
f'|copy(inkey="image", outkey="labels")'
f'|rgb_to_grayscale_to_rgb(inkey="image",outkey="image")'
f'|value_range(-1,1,key="image")'
f'|value_range(-1,1,key="labels")'
f'|keep("image","labels")')
pp_eval = (
f'decode'
f'|resize({arg.res})'
f'|copy(inkey="image", outkey="labels")'
f'|rgb_to_grayscale_to_rgb(inkey="image",outkey="image")'
f'|value_range(-1,1,key="image")'
f'|value_range(-1,1,key="labels")'
f'|keep("image","labels")')
config.log_training_steps = 50
config.ckpt_steps = 1000
config.keep_ckpt_steps = 20_000
# Model section
config.model_name = 'proj.uvim.vit'
config.model = mlc.ConfigDict()
config.model.input_size = (arg.res, arg.res)
config.model.patch_size = (arg.patch_size, arg.patch_size)
config.model.code_len = 256
config.model.width = 768
config.model.enc_depth = 6
config.model.dec_depth = 12
config.model.mlp_dim = 3072
config.model.num_heads = 12
config.model.dict_size = 4096 # Number of words in dict.
config.model.codeword_dim = 768
config.model.dict_momentum = 0.995 # Momentum for dict. learning.
config.model.with_encoder_ctx = True
config.model.with_decoder_ctx = True
config.model.code_dropout = 'random'
config.model.bottleneck_resize = True
config.model.inputs = {
'color': (3, arg.patch_size**2),
}
config.model.outputs = config.model.inputs
# VQVAE-specific params.
config.freeze_dict = False # Will freeze a dict. inside VQ-VAE model.
config.w_commitment = 0.0
# Optimizer section
config.optax_name = 'big_vision.scale_by_adafactor'
config.optax = dict(beta2_cap=0.95)
config.lr = 4e-4
config.wd = 4e-5
config.schedule = dict(decay_type='cosine', warmup_steps=4_000)
config.grad_clip_norm = 1.0
# Evaluation section
config.evals = {}
config.evals.val = mlc.ConfigDict()
config.evals.val.type = 'proj.uvim.compute_mean'
config.evals.val.pred = 'validation'
config.evals.val.data = {**config.input.data}
config.evals.val.data.split = 'train[:4096]'
config.evals.val.pp_fn = pp_eval
config.evals.val.log_steps = 250
base = {
'type': 'proj.uvim.psnr',
'pp_fn': pp_eval.replace('decode|', ''),
'log_steps': 10_000,
}
config.evals.psnr_train = dict(**base, split='train[4096:8192]')
config.evals.psnr_holdout = dict(**base, split='train[:4096]')
config.evals.psnr_val = dict(**base, split='validation')
config.evals.colorization_val_coltran_fid = {
'type': 'proj.uvim.coltran_fid',
'log_steps': 100_000,
}
# config.evals.save_pred = dict(type='proj.uvim.save_predictions')
# config.evals.save_pred.pp = pp_eval.replace('decode|', '')
# config.evals.save_pred.log_steps = 100_000
# config.evals.save_pred.dataset = config.dataset
# config.evals.save_pred.split = 'validation[:1024]'
# config.evals.save_pred.outfile = 'inference.npz'
config.seed = 0
if arg.singlehost:
config.input.batch_size = 128
config.total_epochs = 20
elif arg.runlocal:
config.input.batch_size = 16
config.input.shuffle_buffer_size = 10
config.log_training_steps = 5
config.model.enc_depth = 1
config.model.dec_depth = 1
config.evals.val.data.split = 'validation[:16]'
config.evals.val.log_steps = 20
config.evals.psnr_train.split = 'train[:256]'
config.evals.psnr_train.log_steps = 20
config.evals.psnr_holdout.split = 'train[256:512]'
config.evals.psnr_holdout.log_steps = 20
config.evals.psnr_val.split = 'train[:256]'
config.evals.psnr_val.log_steps = 20
config.evals.colorization_val_coltran_fid.split = 'validation[:256]'
config.evals.colorization_val_coltran_fid.log_steps = 20
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for training a UViM stage II model for the panoptic task.
This config is expected to reproduce the paper's result and achieve
approximately 43.7 PQ points on the COCO holdout data.
We also provide a low-resource variant of this config, which can be enabled
by adding `:singlehost` postfix to the config name. This one is expected to
achieve 39.4 PQ points on the COCO holdout data.
"""
import big_vision.configs.common as bvcc
from ml_collections import ConfigDict
VTT_MODELS = {
'base': dict(num_layers=12, num_heads=12, mlp_dim=3072, emb_dim=768),
'large': dict(num_layers=24, num_heads=16, mlp_dim=4096, emb_dim=1024),
}
VQVAE_MODELS = {
'base': dict(enc_depth=6, dec_depth=12, num_heads=12, mlp_dim=3072, width=768),
}
RES = 512
PATCH_SIZE = 16
LABEL_RES = 512
LABEL_PATCH_SIZE = 16
def get_config(arg=''):
"""Config for training."""
arg = bvcc.parse_arg(arg, runlocal=False, singlehost=False)
config = ConfigDict()
config.input = {}
config.input.pp = (
f'decode|coco_panoptic|concat(["semantics","instances"], "labels")|'
f'randu("fliplr")|det_fliplr(key="image")|det_fliplr(key="labels")|'
f'inception_box|crop_box(key="image")|crop_box(key="labels")|'
f'resize({LABEL_RES}, inkey="image", outkey="image_ctx")|'
f'resize({RES})|resize({LABEL_RES},key="labels",method="nearest")|'
f'value_range(-1, 1, key="image_ctx")|'
f'value_range(-1, 1)|make_canonical|keep("image","image_ctx","labels")'
)
pp_eval = (
f'decode|coco_panoptic|concat(["semantics","instances"], "labels")|'
f'resize({LABEL_RES}, inkey="image", outkey="image_ctx")|'
f'resize({RES})|resize({LABEL_RES},key="labels",method="nearest")|'
f'value_range(-1, 1, key="image_ctx")|'
f'value_range(-1, 1)|make_canonical|keep("image","image_ctx","labels")'
)
pp_predict = (
f'resize({LABEL_RES}, inkey="image", outkey="image_ctx")|resize({RES})|'
f'value_range(-1, 1, key="image_ctx")|value_range(-1, 1)|'
f'keep("image","image_ctx","image/id")' # image/id used for rng seeds.
)
config.input.data = dict(name='coco/2017_panoptic', split='train[4096:]')
config.input.batch_size = 512
config.input.shuffle_buffer_size = 50_000
config.total_epochs = 200
config.log_training_steps = 50
config.ckpt_steps = 1000
config.keep_ckpt_steps = 5000
config.prefetch_to_device = 2
config.seed = 0
# Optimizer section
config.optax_name = 'big_vision.scale_by_adafactor'
config.optax = dict(beta2_cap=0.95)
config.lr = 0.001
config.wd = 0.000001
config.lr_mults = [
('pos_embedding_encoder.*', 0.1),
('EmbedPatches.*', 0.1),
('encoder.*', 0.1),
('decoder.*', 1.0)
]
config.schedule = dict(decay_type='cosine', warmup_steps=4_000)
# Oracle section
config.oracle = ConfigDict()
config.oracle.task = 'proj.uvim.panoptic_task'
config.oracle.model_init = 'gs://big_vision/uvim/panoptic_stageI_params.npz'
config.oracle.model_name = 'proj.uvim.vit'
config.oracle.model = ConfigDict(VQVAE_MODELS['base'])
config.oracle.model.input_size = (LABEL_RES, LABEL_RES)
config.oracle.model.patch_size = (LABEL_PATCH_SIZE, LABEL_PATCH_SIZE)
config.oracle.model.code_len = 256
config.oracle.model.dict_size = 4096
config.oracle.model.codeword_dim = 768
config.oracle.model.with_encoder_ctx = True
config.oracle.model.with_decoder_ctx = True
config.oracle.model.code_dropout = 'random'
config.oracle.model.bottleneck_resize = True
config.oracle.model.inputs = {
'semantics': (133 + 1, LABEL_PATCH_SIZE**2), # +1 for void label
'instances': (100, LABEL_PATCH_SIZE**2), # COCO: actually 98 train/78 validation.
}
config.oracle.model.outputs = config.oracle.model.inputs
# Model section
config.model_name = 'proj.uvim.vtt'
# config.model_init = {'encoder': 'howto-i21k-B/8'}
config.model_init = {'encoder': 'howto-i21k-L/16'}
config.model = ConfigDict(VTT_MODELS['large'])
config.model.patches = ConfigDict({'size': (PATCH_SIZE, PATCH_SIZE)})
config.model.vocab_size = config.oracle.model.get_ref('dict_size') + 1
config.model.posemb_type = 'learn'
config.model.input_size = (RES, RES)
config.model.seq_len = config.oracle.model.get_ref('code_len')
# Evaluation section
config.evals = {}
config.evals.val = ConfigDict()
config.evals.val.type = 'proj.uvim.compute_mean'
config.evals.val.pred = 'validation'
config.evals.val.data = dict(name=config.input.data.name, split='train[:4096]')
config.evals.val.pp_fn = pp_eval
config.evals.val.log_steps = 1000
base = {
'type': 'proj.uvim.coco_panoptic',
'pp_fn': pp_predict,
'log_steps': 10_000,
# Filters objects that occupy less than 0.03^2 fraction of all pixels.
# 'predict_kwargs': {'min_fraction': 0.03 ** 2},
}
config.evals.coco_panoptic_train = dict(**base, split='train[4096:8192]')
config.evals.coco_panoptic_holdout = dict(**base, split='train[:4096]')
config.evals.coco_panoptic = dict(**base, split='validation')
# config.evals.save_pred = dict(type='proj.uvim.save_predictions')
# config.evals.save_pred.pp = pp_eval.replace('decode|', '')
# config.evals.save_pred.log_steps = 100_000
# config.evals.save_pred.dataset = config.dataset
# config.evals.save_pred.split = 'validation[:1024]'
# config.evals.save_pred.outfile = 'inference.npz'
if arg.singlehost:
config.input.batch_size = 32
config.num_epochs = 50
elif arg.runlocal:
config.input.batch_size = 4
config.input.shuffle_buffer_size = 10
config.evals.val.data.split = 'train[:16]'
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for training a UViM stage I model for the panoptic task.
This config is expected to reproduce the paper's result and achieve
approximately 75.7 PQ points on the COCO holdout data.
We also provide a low-resource variant of this config, which can be enabled
by adding `:singlehost` postfix to the config name. This one is expected to
achieve 67.8 PQ points on the COCO holdout data.
"""
import itertools
import big_vision.configs.common as bvcc
import ml_collections as mlc
def get_config(arg='res=512,patch_size=16'):
"""Config for training label compression on COCO-panoptic."""
arg = bvcc.parse_arg(arg, res=512, patch_size=16,
runlocal=False, singlehost=False)
config = mlc.ConfigDict()
config.task = 'proj.uvim.panoptic_task'
config.input = {}
config.input.data = dict(name='coco/2017_panoptic', split='train[4096:]')
config.input.batch_size = 1024
config.input.shuffle_buffer_size = 25_000
config.total_epochs = 1000
config.input.pp = (
f'decode|coco_panoptic|concat(["semantics","instances"], "labels")|'
f'randu("fliplr")|det_fliplr(key="image")|det_fliplr(key="labels")|'
f'inception_box|crop_box(key="image")|crop_box(key="labels")|'
f'resize({arg.res})|resize({arg.res},key="labels",method="nearest")|'
f'value_range(-1, 1)|make_canonical|keep("image","labels")'
)
pp_eval = (
f'decode|coco_panoptic|concat(["semantics","instances"], "labels")|'
f'resize({arg.res})|resize({arg.res},key="labels",method="nearest")|'
f'value_range(-1, 1)|make_canonical|keep("image","labels")'
)
config.log_training_steps = 50
config.ckpt_steps = 1000
config.keep_ckpt_steps = 20_000
# Model section
config.model_name = 'proj.uvim.vit'
config.model = mlc.ConfigDict()
config.model.input_size = (arg.res, arg.res)
config.model.patch_size = (arg.patch_size, arg.patch_size)
config.model.code_len = 256
config.model.width = 768
config.model.enc_depth = 6
config.model.dec_depth = 12
config.model.mlp_dim = 3072
config.model.num_heads = 12
config.model.dict_size = 4096 # Number of words in dict.
config.model.codeword_dim = 768
config.model.dict_momentum = 0.995 # Momentum for dict. learning.
config.model.with_encoder_ctx = True
config.model.with_decoder_ctx = True
config.model.code_dropout = 'random'
config.model.bottleneck_resize = True
config.model.inputs = {
'semantics': (133 + 1, arg.patch_size**2), # +1 for void label
'instances': (100, arg.patch_size**2), # COCO: actually 98 train/78 validation.
}
config.model.outputs = config.model.inputs
# VQVAE-specific params.
config.freeze_dict = False # Will freeze a dict. inside VQ-VAE model.
config.w_commitment = 0.0
# Optimizer section
config.optax_name = 'big_vision.scale_by_adafactor'
config.optax = dict(beta2_cap=0.95)
config.lr = 4e-4
config.wd = 4e-5
config.schedule = dict(decay_type='cosine', warmup_steps=4_000)
config.grad_clip_norm = 1.0
# Evaluation section
config.evals = {}
config.evals.val = mlc.ConfigDict()
config.evals.val.type = 'proj.uvim.compute_mean'
config.evals.val.pred = 'validation'
config.evals.val.data = {**config.input.data}
config.evals.val.data.split = 'train[:4096]'
config.evals.val.pp_fn = pp_eval
config.evals.val.log_steps = 250
base = {
'type': 'proj.uvim.coco_panoptic',
'pp_fn': pp_eval.replace('decode|', ''),
'log_steps': 10_000,
# Filters objects that occupy less than 0.03^2 fraction of all pixels.
# 'predict_kwargs': {'min_fraction': 0.03 ** 2},
}
config.evals.coco_panoptic_train = dict(**base, split='train[4096:8192]')
config.evals.coco_panoptic_holdout = dict(**base, split='train[:4096]')
config.evals.coco_panoptic = dict(**base, split='validation')
# config.evals.save_pred = dict(type='proj.uvim.save_predictions')
# config.evals.save_pred.pp = pp_eval.replace('decode|', '')
# config.evals.save_pred.log_steps = 100_000
# config.evals.save_pred.dataset = config.dataset
# config.evals.save_pred.split = 'validation[:1024]'
# config.evals.save_pred.outfile = 'inference.npz'
config.seed = 0
if arg.singlehost:
config.input.batch_size = 128
config.num_epochs = 100
elif arg.runlocal:
config.input.batch_size = 16
config.input.shuffle_buffer_size = 10
config.log_training_steps = 5
config.model.enc_depth = 1
config.model.dec_depth = 1
config.evals.val.data.split = 'validation[:16]'
config.evals.val.log_steps = 20
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for training a UViM stage II model for the depth task.
"""
import big_vision.configs.common as bvcc
from ml_collections import ConfigDict
VTT_MODELS = {
'base': dict(num_layers=12, num_heads=12, mlp_dim=3072, emb_dim=768),
'large': dict(num_layers=24, num_heads=16, mlp_dim=4096, emb_dim=1024),
}
VQVAE_MODELS = {
'base': dict(enc_depth=6, dec_depth=12, num_heads=12, mlp_dim=3072, width=768),
}
RES = 512
PATCH_SIZE = 16
LABEL_RES = 512
LABEL_PATCH_SIZE = 16
QUANTIZATION_BINS = 256
# Same as values used in eval, see evaluators/nyu_depth.py.
MIN_DEPTH = 1e-3
MAX_DEPTH = 10
def get_config(arg='split=final'):
"""Config for training."""
arg = bvcc.parse_arg(arg, split='final', runlocal=False, singlehost=False)
config = ConfigDict()
config.input = {}
config.input.pp = (
f'decode|nyu_depth|'
f'randu("fliplr")|det_fliplr(key="image")|det_fliplr(key="labels")|'
f'inception_box|crop_box(key="image")|crop_box(key="labels")|'
f'resize({RES})|'
f'resize({LABEL_RES},inkey="image",outkey="image_ctx")|'
f'resize({LABEL_RES},key="labels",method="nearest")|'
f'value_range(-1,1)|'
f'value_range(-1,1,inkey="image_ctx",outkey="image_ctx")|'
f'keep("image","image_ctx","labels")'
)
pp_eval = (
f'decode|nyu_depth|'
f'nyu_eval_crop|'
f'resize({RES})|'
f'resize({LABEL_RES},inkey="image",outkey="image_ctx")|'
f'resize({LABEL_RES},key="labels",method="nearest")|'
f'value_range(-1,1)|'
f'value_range(-1,1,inkey="image_ctx",outkey="image_ctx")|'
f'keep("image","image_ctx","labels")'
)
pp_predict = (
f'nyu_depth|'
f'nyu_eval_crop|copy("labels","ground_truth")|'
f'resize({RES})|'
f'resize({LABEL_RES},inkey="image",outkey="image_ctx")|'
f'value_range(-1,1)|'
f'value_range(-1,1,inkey="image_ctx",outkey="image_ctx")|'
f'keep("image","image_ctx","ground_truth")'
)
config.input.data = dict(name='nyu_depth_v2', split='train')
config.input.batch_size = 512
config.input.shuffle_buffer_size = 50_000
config.total_epochs = 50
config.log_training_steps = 50
config.ckpt_steps = 1000
config.keep_ckpt_steps = 5000
config.prefetch_to_device = 2
config.seed = 0
# Optimizer section
config.optax_name = 'big_vision.scale_by_adafactor'
config.optax = dict(beta2_cap=0.95)
config.optax.clipping_threshold = None
config.lr = 0.001
config.wd = 0.000001
config.lr_mults = (
('pos_embedding_encoder.*', 0.1),
('EmbedPatches.*', 0.1),
('encoder.*', 0.1),
('decoder.*', 1.0)
)
config.schedule = dict(decay_type='cosine', warmup_steps=4_000)
# Oracle section
config.oracle = ConfigDict()
config.oracle.min_depth = MIN_DEPTH
config.oracle.max_depth = MAX_DEPTH
config.oracle.task = 'proj.uvim.depth_task'
config.oracle.model_init = 'gs://big_vision/uvim/depth_stageI_params.npz'
config.oracle.model_name = 'proj.uvim.vit'
config.oracle.model = ConfigDict(VQVAE_MODELS['base'])
config.oracle.model.input_size = (LABEL_RES, LABEL_RES)
config.oracle.model.patch_size = (LABEL_PATCH_SIZE, LABEL_PATCH_SIZE)
config.oracle.model.code_len = 256
config.oracle.model.dict_size = 4096
config.oracle.model.codeword_dim = 768
config.oracle.model.with_encoder_ctx = True
config.oracle.model.with_decoder_ctx = True
config.oracle.model.code_dropout = 'random'
config.oracle.model.bottleneck_resize = True
config.oracle.model.inputs = {
'depth': (QUANTIZATION_BINS, LABEL_PATCH_SIZE**2,),
}
config.oracle.model.outputs = config.oracle.model.inputs
# Model section
config.model_name = 'proj.uvim.vtt'
# config.model_init = {'encoder': 'howto-i21k-B/8''} # B/8 I21K
config.model_init = {'encoder': 'howto-i21k-L/16'} # L/16 I21K
config.model = ConfigDict(VTT_MODELS['large'])
config.model.patches = ConfigDict({'size': (PATCH_SIZE, PATCH_SIZE)})
config.model.vocab_size = config.oracle.model.dict_size + 1
config.model.posemb_type = 'learn'
config.model.input_size = (RES, RES)
config.model.seq_len = config.oracle.model.get_ref('code_len')
config.model.zero_decoder_seq = False
# Evaluation section
config.evals = {}
config.evals.val = ConfigDict()
config.evals.val.type = 'proj.uvim.compute_mean'
config.evals.val.pred = 'validation'
config.evals.val.data = {**config.input.data}
config.evals.val.data.split = 'validation'
config.evals.val.pp_fn = pp_eval
config.evals.val.log_steps = 1000
base = {
'type': 'proj.uvim.nyu_depth',
'dataset': config.input.data.name,
'pp_fn': pp_predict,
'log_steps': 2000,
'min_depth': MIN_DEPTH,
'max_depth': MAX_DEPTH,
}
config.evals.nyu_depth_val = dict(**base, split='validation')
if arg.singlehost:
config.input.batch_size = 32
config.total_epochs = 20
elif arg.runlocal:
config.oracle.model_init = '/tmp/checkpoint.npz'
config.model_init = {'encoder': '/tmp/enc_checkpoint.npz'}
config.evals = {}
config.input.batch_size = 1
config.input.shuffle_buffer_size = 10
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for training a UViM stage I model for the depth task.
"""
import itertools
import big_vision.configs.common as bvcc
import ml_collections as mlc
QUANTIZATION_BINS = 256
# Depths outside of this range will not be evaluated.
MIN_DEPTH = 1e-3
MAX_DEPTH = 10
def get_config(arg='res=512,patch_size=16'):
"""Config for training label compression on NYU depth v2."""
arg = bvcc.parse_arg(arg, res=512, patch_size=16,
runlocal=False, singlehost=False)
config = mlc.ConfigDict()
config.task = 'proj.uvim.depth_task'
config.input = {}
config.input.data = dict(name='nyu_depth_v2', split='train)
config.input.batch_size = 1024
config.input.shuffle_buffer_size = 25_000
config.total_epochs = 200
config.input.pp = (
f'decode|nyu_depth|'
f'randu("fliplr")|det_fliplr(key="image")|det_fliplr(key="labels")|'
f'inception_box|crop_box(key="image")|crop_box(key="labels")|'
f'resize({arg.res})|resize({arg.res},key="labels",method="nearest")|'
f'value_range(-1, 1)|keep("image","labels")'
)
pp_eval = (
f'decode|nyu_depth|nyu_eval_crop|'
f'resize({arg.res})|resize({arg.res},key="labels",method="nearest")|'
f'value_range(-1, 1)|keep("image","labels")'
)
# There are no image IDs in TFDS, so hand through the ground truth for eval.
pp_pred = (
f'nyu_depth|nyu_eval_crop|copy("labels","ground_truth")|'
f'resize({arg.res})|resize({arg.res},key="labels",method="nearest")|'
f'value_range(-1, 1)|'
f'keep("image","labels","ground_truth")'
)
config.log_training_steps = 50
config.ckpt_steps = 1000
config.keep_ckpt_steps = 20_000
# Model section
config.min_depth = MIN_DEPTH
config.max_depth = MAX_DEPTH
config.model_name = 'proj.uvim.vit'
config.model = mlc.ConfigDict()
config.model.input_size = (arg.res, arg.res)
config.model.patch_size = (arg.patch_size, arg.patch_size)
config.model.code_len = 256
config.model.width = 768
config.model.enc_depth = 6
config.model.dec_depth = 12
config.model.mlp_dim = 3072
config.model.num_heads = 12
config.model.dict_size = 4096 # Number of words in dict.
config.model.codeword_dim = 768
config.model.dict_momentum = 0.995 # Momentum for dict. learning.
config.model.with_encoder_ctx = True
config.model.with_decoder_ctx = True
config.model.code_dropout = 'random'
config.model.bottleneck_resize = True
config.model.inputs = {
'depth': (QUANTIZATION_BINS, arg.patch_size**2),
}
config.model.outputs = config.model.inputs
# VQVAE-specific params.
config.freeze_dict = False # Will freeze a dict. inside VQ-VAE model.
config.w_commitment = 0.0
# Optimizer section
config.optax_name = 'big_vision.scale_by_adafactor'
config.optax = dict(beta2_cap=0.95)
config.lr = 1e-3
config.wd = 1e-5
config.schedule = dict(decay_type='cosine', warmup_steps=4_000)
config.grad_clip_norm = 1.0
# Evaluation section
config.evals = {}
config.evals.val = mlc.ConfigDict()
config.evals.val.type = 'proj.uvim.compute_mean'
config.evals.val.pred = 'validation'
config.evals.val.data = {**config.input.data}
config.evals.val.data.split = 'validation'
config.evals.val.pp_fn = pp_eval
config.evals.val.log_steps = 250
base = {
'type': 'proj.uvim.nyu_depth',
'dataset': config.input.data.name,
'pp_fn': pp_pred,
'log_steps': 2000,
'min_depth': MIN_DEPTH,
'max_depth': MAX_DEPTH,
}
config.evals.nyu_depth_val = dict(**base, split='validation')
config.seed = 0
if arg.singlehost:
config.input.batch_size = 128
config.total_epochs = 50
elif arg.runlocal:
config.input.batch_size = 16
config.input.shuffle_buffer_size = 10
config.log_training_steps = 5
config.model.enc_depth = 1
config.model.dec_depth = 1
config.evals.val.data.split = 'validation[:16]'
config.evals.val.log_steps = 20
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""A config for training a UViM stage II model for the colorization task.
"""
import big_vision.configs.common as bvcc
from ml_collections import ConfigDict
VTT_MODELS = {
'base': dict(num_layers=12, num_heads=12, mlp_dim=3072, emb_dim=768),
'large': dict(num_layers=24, num_heads=16, mlp_dim=4096, emb_dim=1024),
}
VQVAE_MODELS = {
'base': dict(enc_depth=6, dec_depth=12, num_heads=12, mlp_dim=3072, width=768),
}
RES = 512
PATCH_SIZE = 16
LABEL_RES = 512
LABEL_PATCH_SIZE = 16
def get_config(arg=''):
"""Config for training."""
arg = bvcc.parse_arg(arg, runlocal=False, singlehost=False)
config = ConfigDict()
config.input = {}
config.input.pp = (
f'decode_jpeg_and_inception_crop({RES})'
f'|flip_lr'
f'|copy(inkey="image", outkey="labels")'
f'|resize({LABEL_RES},inkey="labels",outkey="labels",method="nearest")'
f'|value_range(-1,1,key="labels")'
f'|rgb_to_grayscale_to_rgb(inkey="image",outkey="image")'
f'|value_range(-1,1,key="image")'
f'|copy(inkey="image", outkey="image_ctx")'
f'|resize({LABEL_RES},inkey="image_ctx",outkey="image_ctx")'
f'|keep("image","image_ctx","labels")')
pp_eval = (
f'decode'
f'|resize({RES})'
f'|copy(inkey="image", outkey="labels")'
f'|resize({LABEL_RES},inkey="labels",outkey="labels",method="nearest")'
f'|value_range(-1,1,key="labels")'
f'|rgb_to_grayscale_to_rgb(inkey="image",outkey="image")'
f'|value_range(-1,1,key="image")'
f'|copy(inkey="image", outkey="image_ctx")'
f'|resize({LABEL_RES},inkey="image_ctx",outkey="image_ctx")'
f'|strong_hash(inkey="tfds_id", outkey="image/id")'
f'|keep("image","image_ctx","labels","image/id")')
config.input.data = dict(name='imagenet2012', split='train[4096:]')
config.input.batch_size = 512
config.input.shuffle_buffer_size = 50_000
config.total_epochs = 50
config.log_training_steps = 50
config.ckpt_steps = 1000
config.keep_ckpt_steps = 5000
config.prefetch_to_device = 2
config.seed = 0
# Optimizer section
config.optax_name = 'big_vision.scale_by_adafactor'
config.optax = dict(beta2_cap=0.95)
config.lr = 0.001
config.wd = 0.000001
config.lr_mults = [
('pos_embedding_encoder.*', 0.1),
('EmbedPatches.*', 0.1),
('encoder.*', 0.1),
('decoder.*', 1.0)
]
config.schedule = dict(decay_type='cosine', warmup_steps=4_000)
# Oracle section
config.oracle = ConfigDict()
config.oracle.task = 'proj.uvim.colorization_task'
config.oracle.model_init = 'gs://big_vision/uvim/color_stageI_params.npz'
config.oracle.model_name = 'proj.uvim.vit'
config.oracle.model = ConfigDict(VQVAE_MODELS['base'])
config.oracle.model.input_size = (LABEL_RES, LABEL_RES)
config.oracle.model.patch_size = (LABEL_PATCH_SIZE, LABEL_PATCH_SIZE)
config.oracle.model.code_len = 256
config.oracle.model.dict_size = 4096
config.oracle.model.codeword_dim = 768
config.oracle.model.with_encoder_ctx = True
config.oracle.model.with_decoder_ctx = True
config.oracle.model.code_dropout = 'random'
config.oracle.model.bottleneck_resize = True
config.oracle.model.inputs = {
'color': (3, LABEL_PATCH_SIZE**2),
}
config.oracle.model.outputs = config.oracle.model.inputs
# Model section
config.model_name = 'proj.uvim.vtt'
# config.model_init = {'encoder': 'howto-i21k-B/8'}
config.model_init = {'encoder': 'howto-i21k-L/16'}
config.model = ConfigDict(VTT_MODELS['large'])
config.model.patches = ConfigDict({'size': (PATCH_SIZE, PATCH_SIZE)})
config.model.vocab_size = config.oracle.model.get_ref('dict_size') + 1
config.model.posemb_type = 'learn'
config.model.input_size = (RES, RES)
config.model.seq_len = config.oracle.model.get_ref('code_len')
# Evaluation section
config.evals = {}
config.evals.val = ConfigDict()
config.evals.val.type = 'proj.uvim.compute_mean'
config.evals.val.pred = 'validation'
config.evals.val.data = dict(name=config.input.data.name, split='train[:4096]')
config.evals.val.pp_fn = pp_eval
config.evals.val.log_steps = 1000
base = {
'type': 'proj.uvim.psnr',
'pp_fn': pp_eval.replace('decode|', ''),
'log_steps': 10_000,
}
config.evals.psnr_train = dict(**base, split='train[4096:8192]')
config.evals.psnr_holdout = dict(**base, split='train[:4096]')
config.evals.psnr_val = dict(**base, split='validation')
config.evals.colorization_val_coltran_fid = {
'type': 'proj.uvim.coltran_fid',
'log_steps': 100_000,
}
# config.evals.save_pred = dict(type='proj.uvim.save_predictions')
# config.evals.save_pred.pp_fn = pp_eval.replace('decode|', '')
# config.evals.save_pred.log_steps = 100_000
# config.evals.save_pred.dataset = config.dataset
# config.evals.save_pred.split = 'validation[:1024]'
# config.evals.save_pred.outfile = 'inference.npz'
if arg.singlehost:
config.input.batch_size = 32
config.total_epochs = 20
elif arg.runlocal:
config.input.batch_size = 8
config.input.shuffle_buffer_size = 10
config.evals.val.data.split = 'validation[:256]'
return config |
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Snippets and constants used a lot in image-text configs."""
import ml_collections
# pylint: disable=line-too-long
inits = {
# Downloaded & extracted from original repo:
# https://github.com/google-research/bert
'bert_base': ('base', 'gs://vit_models/lit/bert/uncased_L-12_H-768_A-12'),
'bert_large': ('large', 'gs://vit_models/lit/bert/uncased_L-uncased_L-24_H-1024_A-16'),
# Recommended "How to train your ViT..." checkpoints from
# https://github.com/google-research/vision_transformer#available-vit-models
'B/32': ('B/32', 'gs://vit_models/augreg/B_32-i21k-300ep-lr_0.001-aug_light1-wd_0.1-do_0.0-sd_0.0.npz'),
'B/16': ('B/16', 'gs://vit_models/augreg/B_16-i21k-300ep-lr_0.001-aug_medium1-wd_0.1-do_0.0-sd_0.0.npz'),
'L/16': ('L/16', 'gs://vit_models/augreg/L_16-i21k-300ep-lr_0.001-aug_strong1-wd_0.1-do_0.0-sd_0.0.npz'),
}
# pylint: enable=line-too-long
def _square875(sz):
return f'resize({int(sz/0.875)})|central_crop({sz})|value_range(-1,1)'
def _aspect75(sz):
return f'resize_small({int(sz/0.75)})|central_crop({sz})|value_range(-1,1)'
def _drop_no_real_label(f):
return len(f['real_label']) > 0
def _drop_no_imagenet(f):
return len(f['labels_imagenet']) > 0
DISCLF_DATASET_OVERRIDES = {
'imagenet2012': {'class_names': 'clip', 'split': 'validation'},
'imagenet2012_minival': {
'dataset_name': 'imagenet2012',
'class_names': 'clip',
'split': 'train[99%:]',
},
'imagenet2012_real': {
'split': 'validation',
'class_names': 'clip',
'class_names_dataset_name': 'imagenet2012',
'pp_img': lambda sz: (
_square875(sz) + '|pad_to_shape(inkey="real_label", outkey="label", shape=[10], pad_value=-1)|keep("label", "image")'), # pylint: disable=line-too-long
'filter_fn': _drop_no_real_label,
},
'imagenet_v2': {'class_names': 'clip'},
'imagenet_a': {
'class_names': 'clip',
'pp_img': lambda sz: _aspect75(sz) + '|map("i1k_i1ka")',
},
'imagenet_r': {
'class_names': 'clip',
'pp_img': lambda sz: _square875(sz) + '|map("i1k_i1kr")',
},
}
def get_disclf(sz, *, log_steps, pp_txt=None, dataset_names=('imagenet2012',)):
"""Returns config for discriminative_classifier of specified datasets."""
config = ml_collections.ConfigDict(dict(
dataset_names=list(dataset_names),
type='proj.image_text.discriminative_classifier',
prefix='z/0shot/',
pp_img=_square875(sz),
dataset_overrides={},
log_steps=log_steps,
cache_final=True,
))
if pp_txt:
config.pp_txt = pp_txt
for name in dataset_names:
if name in DISCLF_DATASET_OVERRIDES:
config.dataset_overrides[name] = {**DISCLF_DATASET_OVERRIDES[name]}
d = config.dataset_overrides[name]
if 'pp_img' in d and callable(d['pp_img']):
with d.ignore_type():
d['pp_img'] = d['pp_img'](sz)
return config
def get_coco(
*,
log_steps,
pp_img='resize(224)|value_range(-1, 1)',
pp_txt='tokenize(max_len=16, inkey="texts", eos="sticky", pad_value=1)',
prefix='z/retr/coco_'):
"""Returns config for mscoco retrieval zero-shot.
Args:
log_steps: How often the evaluators should be run.
pp_img: Pre-processing string for "image" feature.
pp_txt: Pre-processing string for texts (expected to tokenize "texts" to
"labels").
prefix: Prefix to use for metrics.
Returns:
`ConfigDict` that can be used as a retrieval evaluator configuration.
"""
return ml_collections.ConfigDict({
'type': 'proj.image_text.retrieval',
'pp_txt': pp_txt,
'pp_img': pp_img,
'prefix': prefix,
'dataset': 'coco_captions',
'txt_name': ('captions', 'text'),
'log_steps': log_steps,
})
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Trains a LiT model as in https://arxiv.org/abs/2111.07991
IMPORTANT NOTE: This config uses coco_captions for demonstration purposes. As of
6/17/22 neither YFCC100M nor CC12M are available in TFDS. We're working on
publishing these datasets to allow for full replication of the numbers reported
in the paper.
Published models:
https://github.com/google-research/vision_transformer#lit-models
Colab to load public LiT models:
https://colab.research.google.com/github/google-research/vision_transformer/blob/main/lit.ipynb
gs://vit_models/lit/LiT-B16B.npz - 72.07% i1k 0shot
gs://vit_models/lit/LiT-L16L.npz - 75.68% i1k 0shot - missing in publication
Example training:
big_vision.trainers.proj.image_text.contrastive \
--config big_vision/configs/proj/image_text/lit_coco.py \
--workdir gs://[your_bucket]/big_vision/`date '+%Y-%m-%d_%H%M'`
Example evaluation:
big_vision.tools.eval_only \
--config big_vision/configs/proj/image_text/lit_coco.py:txt=bert_base,img_head,img=B/16,init=gs://vit_models/lit/LiT-B16B.npz \
--workdir gs://[your_bucket]/big_vision/`date '+%Y-%m-%d_%H%M'`
"""
import big_vision.configs.common as bvcc
from big_vision.configs.proj.image_text import common
from ml_collections import ConfigDict
def get_config(arg=None):
"""The base configuration."""
arg = bvcc.parse_arg(
arg, res=224, runlocal=False, token_len=16, txt='bert_base', img='B/16',
init='', img_head=False)
img_name, img_init = common.inits[arg.img]
txt_name, txt_init = common.inits[arg.txt]
config = ConfigDict()
config.input = {}
config.input.data = dict(name='coco_captions', split='train')
config.input.batch_size = 4096 if not arg.runlocal else 32
config.input.shuffle_buffer_size = 250_000 if not arg.runlocal else 50
config.total_steps = 5_000 if not arg.runlocal else 1
config.init_shapes = [(1, arg.res, arg.res, 3), (1, arg.token_len,)]
config.init_types = ['float32', 'int32']
if arg.init:
vocab_path = arg.init.rsplit('.', 1)[0] + '.txt'
else:
vocab_path = f'{txt_init}/vocab.txt'
tokenizer = lambda inkey: (
f'bert_tokenize(inkey="{inkey}", max_len={arg.token_len}, '
f'vocab_path="{vocab_path}")')
config.input.pp = (
f'decode|resize({arg.res})|flip_lr|randaug(2,10)|value_range(-1,1)'
f'|flatten|{tokenizer("captions/text")}|keep("image", "labels")'
)
pp_eval = (
f'decode|resize({arg.res})|value_range(-1,1)'
f'|flatten|{tokenizer("captions/text")}'
'|keep("image", "labels")'
)
config.pp_modules = [
'ops_general', 'ops_image', 'ops_text', 'proj.flaxformer.bert_ops']
config.log_training_steps = 50
config.ckpt_steps = 1000
# Model section
config.model_name = 'proj.image_text.two_towers'
config.model_load = {}
if arg.init:
config.model_init = arg.init
else:
config.model_init = {'image': img_init, 'text': txt_init}
config.model_load['txt_load_kw'] = {'dont_load': ['head/kernel', 'head/bias']}
if not arg.img_head:
config.model_load['img_load_kw'] = {'dont_load': ['head/kernel', 'head/bias']}
config.model = ConfigDict()
config.model.image_model = 'vit'
config.model.text_model = 'proj.flaxformer.bert'
config.model.image = ConfigDict({
'variant': img_name,
'pool_type': 'tok',
'head_zeroinit': False,
})
config.model.text = ConfigDict({
'config': txt_name,
'head_zeroinit': False,
})
config.model.temperature_init = 10.0
dim = {'B': 768, 'L': 1024}[arg.img[0]]
config.model.out_dim = (dim if arg.img_head else None, dim) # (image_out_dim, text_out_dim)
if txt_name == 'base':
config.optax_name = 'scale_by_adam'
else:
config.optax_name = 'big_vision.scale_by_adafactor'
config.lr = 0.001
config.wd = 0.01
warmup_steps = max(int(0.03 * config.total_steps), 100)
config.schedule = [
('img/.*', None), # Freezes image tower.
('.*', dict(decay_type='cosine', warmup_steps=warmup_steps)),
]
config.grad_clip_norm = 1.0
# Gather representations across TPU cores for larger batch size for loss.
# See Figure 9 from https://arxiv.org/abs/2111.07991
config.loss_use_global_batch = True
# Eval section (Both few-shot and zero-shot)
eval_common = dict(
type='proj.image_text.contrastive',
use_global_batch=config.loss_use_global_batch,
log_steps=500 if not arg.runlocal else 5,
)
config.evals = {}
sub = '[:4]' if arg.runlocal else ''
config.evals.val = {
**eval_common,
'data': dict(name=config.input.data.name, split=f'val{sub}'),
'pp_fn': pp_eval,
}
config.evals.coco = {
**eval_common,
'data': dict(name='coco_captions', split=f'val{sub}'),
'pp_fn': (
f'decode|resize({arg.res})|value_range(-1,1)'
f'|flatten|{tokenizer("captions/text")}|keep("image", "labels")'),
}
config.evals.imagenet = {
**eval_common,
'data': dict(name='imagenet2012', split=f'validation{sub}'),
'pp_fn': (
f'decode|resize({arg.res})|value_range(-1,1)'
'|clip_i1k_label_names'
f'|{tokenizer("labels")}|keep("image", "labels")'),
}
config.evals.disclf = {}
config.evals.disclf.pp_img = f'resize({arg.res})|value_range(-1,1)'
config.evals.disclf.pp_txt = tokenizer('texts')
config.evals.disclf.type = 'proj.image_text.discriminative_classifier'
config.evals.disclf.prefix = 'z/0shot/'
config.evals.disclf.log_steps = eval_common['log_steps']
config.evals.retrieval_coco = common.get_coco(
pp_img=f'resize({arg.res})|value_range(-1, 1)',
pp_txt=tokenizer('texts'),
log_steps=config.evals.disclf.log_steps,
)
config.seed = 0
config.l = config.m = 0
return config
|
# Copyright 2022 Big Vision Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Pre-training ViT on ILSVRC-2012 with GSAM in https://arxiv.org/abs/2203.08065
Run training of a B/32 model:
big_vision.trainers.proj.gsam.train \
--config big_vision/configs/proj/gsam/vit_i1k_gsam_no_aug.py \
--workdir gs://[your_bucket]/big_vision/`date '+%m-%d_%H%M'`
"""
import big_vision.configs.common as bvcc
from big_vision.configs.common_fewshot import get_fewshot_lsr
import ml_collections as mlc
def get_config(arg=None):
"""Config for training."""
arg = bvcc.parse_arg(arg, variant='B/32', runlocal=False)
config = mlc.ConfigDict()
config.dataset = 'imagenet2012'
config.train_split = 'train[:99%]'
config.cache_raw = not arg.runlocal # Needs up to 120GB of RAM!
config.shuffle_buffer_size = 250_000 # Per host, so small-ish is ok.
config.num_classes = 1000
config.loss = 'sigmoid_xent'
config.batch_size = 4096
config.num_epochs = 300
pp_common = (
'|value_range(-1, 1)'
'|onehot(1000, key="{lbl}", key_result="labels")'
'|keep("image", "labels")'
)
config.pp_train = (
'decode_jpeg_and_inception_crop(224)|flip_lr|' +
pp_common.format(lbl='label')
)
pp = 'decode|resize_small(256)|central_crop(224)' + pp_common
# Aggressive pre-fetching because our models here are small, so we not only
# can afford it, but we also need it for the smallest models to not be
# bottle-necked by the input pipeline. Play around with it for -L models tho.
config.prefetch_to_host = 8
config.prefetch_to_device = 4
config.log_training_steps = 50
config.checkpoint_steps = 1000
# Model section
config.model_name = 'vit'
config.model = dict(
variant=arg.variant,
rep_size=False,
pool_type='gap',
)
config.init_head_bias = -10.0
# Optimizer section
config.grad_clip_norm = 1.0
config.optax_name = 'scale_by_adam'
config.optax = dict(mu_dtype='float32')
# The modified AdaFactor we introduced in https://arxiv.org/abs/2106.04560
# almost always behaves exactly like adam, but at a fraction of the memory
# cost (specifically, adam_bf16 = +1.5M, adafactor = +0.5M), hence it is a
# good idea to try it when you are memory-bound!
# config.optax_name = 'big_vision.scale_by_adafactor'
# A good flag to play with when hitting instabilities, is the following:
# config.optax = dict(beta2_cap=0.95)
config.lr = 0.003
config.wd = 0.001 # default is 0.0001; paper used 0.3, effective wd=0.3*lr
config.schedule = dict(
warmup_steps=10_000,
decay_type='linear',
linear_end=0.01,
)
# GSAM settings.
# Note: when rho_max=rho_min and alpha=0, GSAM reduces to SAM.
config.gsam = dict(
rho_max=0.6,
rho_min=0.1,
alpha=0.6,
lr_max=config.get_ref('lr'),
lr_min=config.schedule.get_ref('linear_end') * config.get_ref('lr'),
)
# Eval section
eval_common = dict(
type='classification',
dataset='imagenet2012',
pp_fn=pp.format(lbl='label'),
loss_name=config.loss,
log_steps=2500, # Very fast O(seconds) so it's fine to run it often.
)
config.evals = {}
config.evals.train = {**eval_common, 'split': 'train[:2%]'}
config.evals.minival = {**eval_common, 'split': 'train[99%:]'}
config.evals.val = {**eval_common, 'split': 'validation'}
config.evals.v2 = {**eval_common, 'dataset': 'imagenet_v2', 'split': 'test'}
config.evals.real = {**eval_common}
config.evals.real.dataset = 'imagenet2012_real'
config.evals.real.split = 'validation'
config.evals.real.pp_fn = pp.format(lbl='real_label')
config.fewshot = get_fewshot_lsr(runlocal=arg.runlocal)
config.fewshot.log_steps = 10_000
# Make a few things much smaller for quick local debugging testruns.
if arg.runlocal:
config.shuffle_buffer_size = 10
config.batch_size = 8
config.minival.split = 'train[:16]'
config.val.split = 'validation[:16]'
config.real.split = 'validation[:16]'
config.v2.split = 'test[:16]'
return config
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Metrics for evaluating Byte models."""
import re
import string
import nltk
from nltk.translate.bleu_score import sentence_bleu
import numpy as np
from t5.evaluation import metrics as t5_metrics
def cer(targets, predictions):
"""Computes the Character Error Rate (CER).
The Character Error Rate for a (input word, target word) pair is defined as
the minimum number of edits required to transform the input word to the target
word divided by the total number of characters in the target word. The minimum
number of edits is calculated using Levenshtein distance, where any
single-character edit (insertion, deletion, substitution) is allowed.
The CER for a list of (input word, target word) pairs is defined as the total
number of edits required to transform each input word into the corresponding
target word divided by the sum of the number of characters in the target
words. For example, given:
targets = ["abc", "aa"]
predictions = ["abd", "a"]
the CER would be: (1 + 1) / (3 + 2) = 2 / 5 = 0.4
Args:
targets: list of strings.
predictions: list of strings.
Returns:
float, CER value for the predictions compared to the targets.
"""
total_characters = 0
total_edit_distance = 0
for target, prediction in zip(targets, predictions):
total_edit_distance += nltk.edit_distance(target, prediction)
total_characters += len(target)
return {'cer': float(total_edit_distance) / total_characters}
def _normalize_text(text):
"""Normalize text for TweetQA task.
Args:
text: string
Returns:
normalized string
"""
# Lower case.
text = text.lower()
# Remove punctuation.
text = ''.join(ch for ch in text if ch not in set(string.punctuation))
# Remove articles.
text = re.sub(r'\b(a|an|the)\b', ' ', text)
# Fix extra whitespaces.
text = ' '.join(text.split())
return text
def bleu1(targets, predictions):
"""BLEU-1 with normalized targets and predictions.
Code has been adapted from tweetqa_eval.py since we want this BLEU-1
calculation to be identical to that used in the TweetQA paper.
Args:
targets: list of strings.
predictions: list of strings.
Returns:
A dictionary that looks like: {"bleu": <value>}
"""
bleu_scores = []
for target, prediction in zip(targets, predictions):
target = _normalize_text(target)
prediction = _normalize_text(prediction)
# By setting the weights tuple to be (1, 0, 0, 0), only uni-grams are
# counted towards the BLEU score, resulting in BLEU-1.
score = sentence_bleu(
[target.split()], prediction.split(), weights=(1, 0, 0, 0)) * 100
bleu_scores.append(score)
return {'bleu1': np.mean(bleu_scores)}
def rouge(targets, predictions):
"""Rouge metrics with normalized targets and predictions.
Args:
targets: list of strings.
predictions: list of strings.
Returns:
A dictionary that looks like:
{"rouge1": <value>, "rouge2": <value>, "rougeLsum": <value>}
"""
targets = [_normalize_text(x) for x in targets]
predictions = [_normalize_text(x) for x in predictions]
return t5_metrics.rouge(targets, predictions)
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
r"""Get the stats of input and target length for T5/mT5/ByT5 tasks.
If the input length is too long which causes OOM, one could truncate the length
to 1.1 * 99th percentile length.
"""
from absl import app
from absl import flags
import byt5.sigmorphon # pylint:disable=unused-import
import byt5.tasks # pylint:disable=unused-import
import multilingual_t5.tasks # pylint:disable=unused-import
import t5
FLAGS = flags.FLAGS
flags.DEFINE_string("task_or_mixture", None, "task/mixture name")
flags.DEFINE_string("split", "train", "train, validation, or test.")
flags.DEFINE_boolean("use_cached", True, "Use cached or not.")
flags.DEFINE_integer("num_samples", None,
"Number of samples to take to compute the lengths.")
MAX_LENGH = int(10e8)
def get_perc_99_len(input_length):
"""Get 99 percentile sequence length."""
lengths = sorted(input_length)
perc_99 = len(input_length) * 99 // 100
perc_99_len = lengths[perc_99]
return perc_99_len
def get_stats(task_or_mixture, split="train"):
"""Get task length stats.
Args:
task_or_mixture: string, task or mixture name.
split: string, split.
"""
print(f"Get length statistics for {task_or_mixture} {split}...")
if task_or_mixture in t5.data.seqio.TaskRegistry.names():
data = t5.data.seqio.TaskRegistry.get(task_or_mixture)
elif task_or_mixture in t5.data.seqio.MixtureRegistry.names():
data = t5.data.seqio.MixtureRegistry.get(task_or_mixture)
else:
raise ValueError(f"{task_or_mixture} {split} is not registered.")
data = data.get_dataset(split=split,
sequence_length={"inputs": MAX_LENGH,
"targets": MAX_LENGH},
use_cached=FLAGS.use_cached,
num_epochs=1)
if FLAGS.num_samples: data = data.take(FLAGS.num_samples)
ds = data.as_numpy_iterator()
input_lengths, target_lengths = [], []
for ex in ds:
input_lengths.append(len(ex["inputs"]))
target_lengths.append(len(ex["targets"]))
recommend_input_length = 1.1 * get_perc_99_len(input_lengths)
output = (f"Total # of examples in {split}: {len(input_lengths)}\n"
f"Min input length: {min(input_lengths)}\n"
f"Max input length: {max(input_lengths)}\n"
f"1.1 * 99 percertile of length: {recommend_input_length}\n"
f"Min target length: {min(target_lengths)}\n"
f"Max target length: {max(target_lengths)}\n")
print(output)
def main(_):
get_stats(FLAGS.task_or_mixture, split=FLAGS.split)
if __name__ == "__main__":
app.run(main)
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Add ByT5 Tasks to registry."""
import functools
import byt5.metrics as byt5_metrics
from multilingual_t5 import preprocessors
from multilingual_t5 import utils
from multilingual_t5.evaluation import metrics as mt5_metrics
from multilingual_t5.tasks import DEFAULT_OUTPUT_FEATURES as DEFAULT_MT5_OUTPUT_FEATURES
import seqio
import t5.data
import t5.data.tasks
from t5.evaluation import metrics
import tensorflow_datasets as tfds
MEAN_NOISE_SPAN_LENGTH = 20
DEFAULT_TEMPERATURE = 1.0 / 0.3
DEFAULT_MIX_RATE = functools.partial(
t5.data.rate_num_examples, temperature=DEFAULT_TEMPERATURE)
DEFAULT_PREPROCESSORS = [
seqio.preprocessors.tokenize,
seqio.CacheDatasetPlaceholder(),
seqio.preprocessors.append_eos_after_trim,
]
DEFAULT_BYTE_OUTPUT_FEATURES = {
"inputs": t5.data.Feature(vocabulary=t5.data.ByteVocabulary()),
"targets": t5.data.Feature(vocabulary=t5.data.ByteVocabulary())
}
FEATURE_MAP = {
"byt5": DEFAULT_BYTE_OUTPUT_FEATURES,
"mt5": DEFAULT_MT5_OUTPUT_FEATURES,
}
MC4_LANGS = tfds.text.c4.MC4_LANGUAGES
# =========================== Pretraining Tasks/Mixtures =======================
# mC4
for lang in MC4_LANGS:
seqio.TaskRegistry.add(
"byt5_mc4.{}".format(lang.replace("-", "_")),
source=seqio.TfdsDataSource(
tfds_name="c4/multilingual:3.0.1",
splits={
"train": lang,
"validation": f"{lang}-validation"
}),
preprocessors=[
functools.partial(
t5.data.preprocessors.rekey,
key_map={
"inputs": None,
"targets": "text"
}),
seqio.preprocessors.tokenize,
seqio.CacheDatasetPlaceholder(),
functools.partial(t5.data.preprocessors.span_corruption,
mean_noise_span_length=MEAN_NOISE_SPAN_LENGTH),
seqio.preprocessors.append_eos_after_trim,
],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[])
mc4 = ["byt5_mc4.{}".format(lang.replace("-", "_")) for lang in MC4_LANGS]
seqio.MixtureRegistry.add("byt5_mc4", mc4, default_rate=DEFAULT_MIX_RATE)
# =========================== Fine-tuning Tasks/Mixtures =======================
# ----- XNLI -----
# XNLI zero-shot task. This fine-tunes on English MNLI training data and then
# evaluates on multilingual XNLI dev/test data.
XNLI_LANGS = [
"ar", "bg", "de", "el", "en", "es", "fr", "hi", "ru", "sw", "th", "tr",
"ur", "vi", "zh"
]
seqio.TaskRegistry.add(
"byt5_xnli_train",
source=seqio.TfdsDataSource(tfds_name="multi_nli:1.1.0", splits=["train"]),
preprocessors=[
preprocessors.process_mnli,
*DEFAULT_PREPROCESSORS,
],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.accuracy])
for lang in XNLI_LANGS:
seqio.TaskRegistry.add(
"byt5_xnli_dev_test.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="xnli:1.1.0", splits=["validation", "test"]),
preprocessors=[
functools.partial(
preprocessors.process_xnli, target_languages=[lang]),
*DEFAULT_PREPROCESSORS,
],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.accuracy])
if lang == "en":
continue
seqio.TaskRegistry.add(
"byt5_xnli_translate_train.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="xtreme_xnli:1.1.0", splits=["train"]),
preprocessors=[
functools.partial(
preprocessors.process_xnli, target_languages=[lang]),
*DEFAULT_PREPROCESSORS,
],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.accuracy])
seqio.TaskRegistry.add(
"byt5_xnli_dev_test.all_langs",
source=seqio.TfdsDataSource(
tfds_name="xnli:1.1.0", splits=["validation", "test"]),
preprocessors=[
functools.partial(
preprocessors.process_xnli, target_languages=XNLI_LANGS),
*DEFAULT_PREPROCESSORS,
],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.accuracy])
xnli_zeroshot = (["byt5_xnli_train", "byt5_xnli_dev_test.all_langs"] +
["byt5_xnli_dev_test.{}".format(lang) for lang in XNLI_LANGS])
seqio.MixtureRegistry.add("byt5_xnli_zeroshot", xnli_zeroshot, default_rate=1.0)
xnli_translate_train = xnli_zeroshot + [
"byt5_xnli_translate_train.{}".format(lang)
for lang in XNLI_LANGS
if lang != "en"
]
seqio.MixtureRegistry.add(
"byt5_xnli_translate_train", xnli_translate_train, default_rate=1.0)
# ----- PAWS -----
label_names = ["different_meaning", "paraphrase"]
text_preprocessor = [
functools.partial(
t5.data.preprocessors.glue,
benchmark_name="paws",
label_names=label_names,
feature_names=["sentence1", "sentence2"],
id_key=None)
]
postprocess_fn = functools.partial(
t5.data.postprocessors.string_label_to_class_id,
label_classes=label_names)
seqio.TaskRegistry.add(
"byt5_paws",
source=seqio.TfdsDataSource(
tfds_name="paws_x_wiki/en:1.0.0", splits=["train"]),
preprocessors=text_preprocessor + DEFAULT_PREPROCESSORS,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
postprocess_fn=postprocess_fn,
metric_fns=[metrics.accuracy])
for lang in utils.PAWSX_LANGS:
seqio.TaskRegistry.add(
"byt5_pawsx_dev_test.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="paws_x_wiki/{}:1.0.0".format(lang),
splits=["validation", "test"]),
preprocessors=text_preprocessor + DEFAULT_PREPROCESSORS,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
postprocess_fn=postprocess_fn,
metric_fns=[metrics.accuracy])
# This uses machine translations provided by the PAWS-X paper.
seqio.TaskRegistry.add(
"byt5_pawsx_translate_train_original.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="paws_x_wiki/{}:1.0.0".format(lang), splits=["train"]),
preprocessors=text_preprocessor + DEFAULT_PREPROCESSORS,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
postprocess_fn=postprocess_fn,
metric_fns=[metrics.accuracy])
if lang != "en":
# This uses machine translations provided by the XTREME paper.
seqio.TaskRegistry.add(
"byt5_pawsx_translate_train.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="xtreme_pawsx/{}:1.0.0".format(lang), splits=["train"]),
preprocessors=text_preprocessor + DEFAULT_PREPROCESSORS,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
postprocess_fn=postprocess_fn,
metric_fns=[metrics.accuracy])
seqio.TaskRegistry.add(
"byt5_pawsx_dev_test.all_langs",
source=seqio.FunctionDataSource(
dataset_fn=utils.pawsx_all_langs_dataset_fn,
splits=["validation", "test"]),
preprocessors=text_preprocessor + DEFAULT_PREPROCESSORS,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
postprocess_fn=postprocess_fn,
metric_fns=[metrics.accuracy])
# PAWSX Zero-Shot
pawsx_eval = [
"byt5_pawsx_dev_test.{}".format(lang) for lang in utils.PAWSX_LANGS
] + ["byt5_pawsx_dev_test.all_langs"]
pawsx = ["byt5_paws"] + pawsx_eval
seqio.MixtureRegistry.add("byt5_pawsx_zeroshot", pawsx, default_rate=1.0)
pawsx_translate_train = ["byt5_paws"] + [
"byt5_pawsx_translate_train.{}".format(lang)
for lang in utils.PAWSX_LANGS
if lang != "en"
] + pawsx_eval
seqio.MixtureRegistry.add(
"byt5_pawsx_translate_train", pawsx_translate_train, default_rate=1.0)
pawsx_translate_train_original = [
"byt5_pawsx_translate_train_original.{}".format(lang)
for lang in utils.PAWSX_LANGS
] + pawsx_eval
seqio.MixtureRegistry.add(
"byt5_pawsx_translate_train_original",
pawsx_translate_train,
default_rate=1.0)
# ----- TyDiQA GoldP-----
# The "validation" split contains all the validation examples for all the
# individual languages together.
TYDIQA_LANGS = ["ar", "bn", "en", "fi", "id", "ko", "ru", "sw", "te"]
seqio.TaskRegistry.add(
"byt5_tydiqa_train_dev",
source=seqio.TfdsDataSource(
tfds_name="tydi_qa/goldp:2.1.0", splits=["train", "validation"]),
preprocessors=[
preprocessors.xquad,
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.squad])
for lang in TYDIQA_LANGS:
seqio.TaskRegistry.add(
"byt5_tydiqa_dev.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="tydi_qa/goldp:2.1.0",
splits={"validation": "validation-{}".format(lang)}),
preprocessors=[
preprocessors.xquad,
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.squad])
tydiqa = (["byt5_tydiqa_train_dev"] +
["byt5_tydiqa_dev.{}".format(lang) for lang in TYDIQA_LANGS])
seqio.MixtureRegistry.add("byt5_tydiqa", tydiqa, default_rate=1.0)
# ----- TyDiQA GoldP Zero-Shot-----
# This Zero-Shot setting matches the XTREME setup, where training is done on
# the English data of TyDiQa. In the TyDiQA paper, fine-tuning was done on
# SQuAD for zero-shot evaluation.
TYDIQA_LANGS = ["ar", "bn", "en", "fi", "id", "ko", "ru", "sw", "te"]
seqio.TaskRegistry.add(
"byt5_tydiqa_train.en",
source=seqio.TfdsDataSource(
tfds_name="tydi_qa/goldp:2.1.0", splits=["train"]),
preprocessors=[
preprocessors.xquad,
functools.partial(
preprocessors.filter_tydiqa_by_language, lang="english"),
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.squad])
tydiqa_zeroshot = (["byt5_tydiqa_train.en"] +
["byt5_tydiqa_dev.{}".format(lang) for lang in TYDIQA_LANGS])
seqio.MixtureRegistry.add(
"byt5_tydiqa_zeroshot", tydiqa_zeroshot, default_rate=1.0)
# Defining translate-train tasks.
for lang in TYDIQA_LANGS:
# Skipping English, since translate-train is not available.
if lang == "en":
continue
seqio.TaskRegistry.add(
"byt5_tydiqa_translate_train.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="tydi_qa/goldp:2.1.0",
splits={"train": "translate-train-{}".format(lang)}),
preprocessors=[
preprocessors.xquad,
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.squad])
tydiqa_translate_train = (
["byt5_tydiqa_train.en"]
+ [f"byt5_tydiqa_translate_train.{lang}"
for lang in TYDIQA_LANGS if lang != "en"]
+ [f"byt5_tydiqa_dev.{lang}" for lang in TYDIQA_LANGS])
seqio.MixtureRegistry.add(
"byt5_tydiqa_translate_train", tydiqa_translate_train, default_rate=1.0)
# ----- English SQUAD -----
seqio.TaskRegistry.add(
"byt5_squad_train_dev",
source=seqio.TfdsDataSource(
tfds_name="squad/v1.1:3.0.0", splits=["train", "validation"]),
preprocessors=[
preprocessors.xquad,
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.squad])
# ----- XQuAD -----
for lang in utils.XQUAD_LANGS_TRAIN_DEV:
seqio.TaskRegistry.add(
"byt5_xquad_translate_train_dev.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="xquad/{}:3.0.0".format(lang),
splits={
"train": "translate-train",
"validation": "translate-dev"
}),
preprocessors=[
preprocessors.xquad,
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.squad])
for lang in utils.XQUAD_LANGS_TEST:
seqio.TaskRegistry.add(
"byt5_xquad_test.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="xquad/{}:3.0.0".format(lang), splits=["test"]),
preprocessors=[
preprocessors.xquad,
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.squad])
# Additional test task containing all the languages.
seqio.TaskRegistry.add(
"byt5_xquad_test.all_langs",
source=seqio.FunctionDataSource(
dataset_fn=utils.xquad_all_langs_dataset_fn, splits=["test"]),
preprocessors=[
preprocessors.xquad,
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[metrics.squad])
# XQuAD Zero-Shot (SQuAD train, SQuAD dev, XQuAD test).
xquad_test = (["byt5_xquad_test.{}".format(lang)
for lang in utils.XQUAD_LANGS_TEST])
xquad_zeroshot = (["byt5_squad_train_dev", "byt5_xquad_test.all_langs"] +
xquad_test)
seqio.MixtureRegistry.add(
"byt5_xquad_zeroshot", xquad_zeroshot, default_rate=1.0)
# XQuAD Translate-Train (English SQuAD, XQuAD translate-train,
# XQuAD translate-dev, XQuAD test)
# Note that the QA translate-train baselines from Hu et al (XTREME)
# do not include the English data. However, Fang et al (FILTER) do include
# English data.
xquad_translate_train = [
"byt5_xquad_translate_train_dev.{}".format(lang)
for lang in utils.XQUAD_LANGS_TRAIN_DEV
] + ["byt5_squad_train_dev"] + ["byt5_xquad_test.all_langs"] + xquad_test
seqio.MixtureRegistry.add(
"byt5_xquad_translate_train", xquad_translate_train, default_rate=1.0)
# ----- MLQA -----
MLQA_LANGS = ["ar", "de", "en", "es", "hi", "vi", "zh"]
for lang in MLQA_LANGS:
seqio.TaskRegistry.add(
"byt5_mlqa_dev_test.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="mlqa/{}:1.0.0".format(lang), splits=["validation",
"test"]),
preprocessors=[
preprocessors.xquad,
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.qa,
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[functools.partial(mt5_metrics.mlqa, lang=lang)])
# MLQA Zero-Shot
mlqa_dev_test = [f"byt5_mlqa_dev_test.{lang}" for lang in MLQA_LANGS]
mlqa_zeroshot = ["byt5_squad_train_dev"] + mlqa_dev_test
seqio.MixtureRegistry.add("byt5_mlqa_zeroshot", mlqa_zeroshot, default_rate=1.0)
# MLQA Translate-Train
mlqa_translate_train = [
"byt5_xquad_translate_train_dev.{}".format(lang)
for lang in MLQA_LANGS
if lang != "en"
] + ["byt5_squad_train_dev"] + mlqa_dev_test
seqio.MixtureRegistry.add(
"byt5_mlqa_translate_train", mlqa_translate_train, default_rate=1.0)
# Wikilingua
# The version of Wikilingua here is the one from the GEM dataset:
# https://arxiv.org/pdf/2102.01672.pdf.
# Note: It was found that there is some data leakage in the GEM WikiLingua
# data with English target summaries in the test set of one language
# appearing in the training set of another language. Training in a multi-task
# setup is not recommended till this issue is resolved.
# TODO(adityabarua): Remove this comment when the issue is resolved.
WIKILINGUA_LANGS = ["es", "ru", "tr", "vi"]
for model, features in FEATURE_MAP.items():
for lang in WIKILINGUA_LANGS:
seqio.TaskRegistry.add(
"{model}_wikilingua.{lang}".format(model=model, lang=lang),
source=seqio.TfdsDataSource(
tfds_name="gem/wiki_lingua_{lang}_en:1.0.1".format(lang=lang)),
preprocessors=[
functools.partial(
t5.data.preprocessors.rekey,
key_map={"inputs": "source",
"targets": "target"}),
*DEFAULT_PREPROCESSORS,
],
output_features=features,
metric_fns=[metrics.rouge])
seqio.MixtureRegistry.add(
"{model}_wikilingua".format(model=model),
["{model}_wikilingua.{lang}".format(model=model, lang=lang) for
lang in WIKILINGUA_LANGS],
default_rate=1.0)
# SuperGLUE
for b in tfds.text.super_glue.SuperGlue.builder_configs.values():
# We use a simplified version of WSC, defined below
if "wsc" in b.name:
continue
if b.name == "axb":
text_preprocessor = [
functools.partial(
t5.data.preprocessors.rekey,
key_map={
"premise": "sentence1",
"hypothesis": "sentence2",
"label": "label",
"idx": "idx",
}),
t5.data.glue_utils.get_glue_text_preprocessor(b),
]
else:
text_preprocessor = [t5.data.glue_utils.get_glue_text_preprocessor(b)]
seqio.TaskRegistry.add(
"byt5_super_glue_%s_v102" % b.name,
source=seqio.TfdsDataSource(
tfds_name="super_glue/%s:1.0.2" % b.name,
splits=["test"] if b.name in ["axb", "axg"] else None),
preprocessors=text_preprocessor + DEFAULT_PREPROCESSORS,
metric_fns=t5.data.glue_utils.get_super_glue_metric(b.name),
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
postprocess_fn=t5.data.glue_utils.get_glue_postprocess_fn(b))
# Definitely Pronoun Resolution
seqio.TaskRegistry.add(
"byt5_dpr_v001_simple",
source=seqio.TfdsDataSource(tfds_name="definite_pronoun_resolution:1.1.0"),
preprocessors=[
t5.data.preprocessors.definite_pronoun_resolution_simple,
*DEFAULT_PREPROCESSORS,
],
metric_fns=[metrics.accuracy],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES)
# WSC
seqio.TaskRegistry.add(
"byt5_super_glue_wsc_v102_simple_train",
source=seqio.TfdsDataSource(
tfds_name="super_glue/wsc.fixed:1.0.2", splits=["train"]),
preprocessors=[
functools.partial(
t5.data.preprocessors.wsc_simple, correct_referent_only=True),
*DEFAULT_PREPROCESSORS,
],
metric_fns=[],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES)
seqio.TaskRegistry.add(
"byt5_super_glue_wsc_v102_simple_eval",
source=seqio.TfdsDataSource(
tfds_name="super_glue/wsc.fixed:1.0.2", splits=["validation", "test"]),
preprocessors=[
functools.partial(
t5.data.preprocessors.wsc_simple, correct_referent_only=False),
*DEFAULT_PREPROCESSORS,
],
postprocess_fn=t5.data.postprocessors.wsc_simple,
metric_fns=[metrics.accuracy],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES)
_byt5_super_glue_tasks = {}
for task, value in t5.data.get_super_glue_weight_mapping().items():
_byt5_super_glue_tasks["byt5_" + task] = value
seqio.MixtureRegistry.add(
"byt5_super_glue_v102_proportional",
list(_byt5_super_glue_tasks.items()))
# GLUE
for b in tfds.text.glue.Glue.builder_configs.values():
seqio.TaskRegistry.add(
"byt5_glue_%s_v002" % b.name,
source=seqio.TfdsDataSource(
tfds_name="glue/%s:1.0.0" % b.name,
splits=["test"] if b.name == "ax" else None),
preprocessors=[
t5.data.glue_utils.get_glue_text_preprocessor(b),
*DEFAULT_PREPROCESSORS,
],
metric_fns=t5.data.glue_utils.get_glue_metric(b.name),
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
postprocess_fn=t5.data.glue_utils.get_glue_postprocess_fn(b))
seqio.MixtureRegistry.add(
"byt5_glue_v002_proportional",
list({
f"byt5_{k}": v
for k, v in t5.data.glue_utils.get_glue_weight_mapping().items()
}.items()))
# ------ WMT ----------
for prefix, b, tfds_version in t5.data.tasks.b_configs:
seqio.TaskRegistry.add(
"byt5_wmt%s_%s%s_v003" % (prefix, b.language_pair[1], b.language_pair[0]),
source=seqio.TfdsDataSource(tfds_name="wmt%s_translate/%s:%s" %
(prefix, b.name, tfds_version)),
preprocessors=[
functools.partial(
t5.data.preprocessors.translate,
source_language=b.language_pair[1],
target_language=b.language_pair[0],
),
*DEFAULT_PREPROCESSORS,
],
metric_fns=[metrics.bleu],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES)
# Special case for t2t ende.
b = tfds.translate.wmt_t2t.WmtT2tTranslate.builder_configs["de-en"]
seqio.TaskRegistry.add(
"byt5_wmt_t2t_ende_v003",
source=seqio.TfdsDataSource(tfds_name="wmt_t2t_translate/de-en:1.0.0"),
preprocessors=[
functools.partial(
t5.data.preprocessors.translate,
source_language=b.language_pair[1],
target_language=b.language_pair[0],
),
*DEFAULT_PREPROCESSORS,
],
metric_fns=[metrics.bleu],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES)
# ----- WikiAnn NER -----
NER_LANGS = [
"af", "ar", "bg", "bn", "de", "el", "en", "es", "et", "eu", "fa", "fi",
"fr", "he", "hi", "hu", "id", "it", "ja", "jv", "ka", "kk", "ko", "ml",
"mr", "ms", "my", "nl", "pt", "ru", "sw", "ta", "te", "th", "tl", "tr",
"ur", "vi", "yo", "zh"
]
for lang in NER_LANGS:
seqio.TaskRegistry.add(
"byt5_ner_train.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="wikiann/{}:1.0.0".format(lang), splits=["train"]),
preprocessors=[
preprocessors.wikiann,
*DEFAULT_PREPROCESSORS,
],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[mt5_metrics.span_f1])
seqio.TaskRegistry.add(
"byt5_ner_eval.{}".format(lang),
source=seqio.TfdsDataSource(
tfds_name="wikiann/{}:1.0.0".format(lang),
splits=["validation", "test"]),
preprocessors=[
preprocessors.wikiann,
*DEFAULT_PREPROCESSORS,
],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES,
metric_fns=[mt5_metrics.span_f1])
# NER zero-shot
seqio.MixtureRegistry.add(
"byt5_ner_zeroshot", ["byt5_ner_train.{}".format("en")] +
["byt5_ner_eval.{}".format(lang) for lang in NER_LANGS],
default_rate=1.0)
# NER multilingual
seqio.MixtureRegistry.add(
"byt5_ner_multilingual",
["byt5_ner_train.{}".format(lang) for lang in NER_LANGS] +
["byt5_ner_eval.{}".format(lang) for lang in NER_LANGS],
default_rate=1.0)
# ----- GEM-XSum -----
_rouge_fn = functools.partial(
metrics.rouge,
score_keys=["rouge1", "rouge2", "rougeL", "rougeLsum"])
seqio.TaskRegistry.add(
"byt5_gem_xsum",
source=seqio.TfdsDataSource(tfds_name="gem/xsum:1.0.1"),
preprocessors=[
functools.partial(
t5.data.preprocessors.summarize,
article_key="document",
summary_key="target"),
*DEFAULT_PREPROCESSORS,
],
metric_fns=[metrics.bleu, _rouge_fn],
output_features=DEFAULT_BYTE_OUTPUT_FEATURES)
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for byt5.metrics."""
from absl.testing import absltest
from byt5 import metrics
class MetricsTest(absltest.TestCase):
def test_edit_distance(self):
d = metrics.cer(["abcd", "aaaa", "ab"],
["abde", "bbbb", "a"])
# abcd -> abde (2 edits). Target length = 4.
# aaaa -> bbbb (4 edits). Target length = 4.
# ab -> a (1 edit). Target length = 2.
# CER = Total # of edits / Total # of target chars = 7 / 10 = 0.7
self.assertDictEqual(d, {"cer": 0.7})
def test_normalize_text(self):
output = metrics._normalize_text(" THIS is a string!")
expected = "this is string"
self.assertEqual(output, expected)
def test_bleu1_full_match(self):
targets = ["this is a string", "this is a string", "this is a string",
"this is a string"]
predictions = ["this is a string", "THIS is a string", "this is a string!",
"this is string"]
d = metrics.bleu1(targets, predictions)
# Normalization should remove articles, extra spaces and punctuations,
# resulting in a BLEU-1 score of 100.0.
self.assertDictEqual(d, {"bleu1": 100.0})
def test_bleu1_no_full_match(self):
targets = ["this is a string"]
predictions = ["this is not a string"]
d = metrics.bleu1(targets, predictions)
self.assertDictEqual(d, {"bleu1": 75.0})
def test_rouge_full_match(self):
targets = ["this is a string", "this is a string", "this is a string",
"this is a string"]
predictions = ["this is a string", "THIS is a string", "this is a string!",
"this is string"]
d = metrics.rouge(targets, predictions)
self.assertDictEqual(d, {"rouge1": 100, "rouge2": 100, "rougeLsum": 100})
def test_rouge_no_match(self):
targets = ["this is a string"]
predictions = ["", ""]
d = metrics.rouge(targets, predictions)
self.assertDictEqual(d, {"rouge1": 0.0, "rouge2": 0.0, "rougeLsum": 0.0})
if __name__ == "__main__":
absltest.main()
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for ByT5 tasks."""
from absl import logging
from absl.testing import absltest
from absl.testing import parameterized
import byt5.sigmorphon # pylint:disable=unused-import
import byt5.tasks # pylint:disable=unused-import
import t5
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
tf.enable_eager_execution()
MixtureRegistry = t5.data.MixtureRegistry
TaskRegistry = t5.data.TaskRegistry
_SEQUENCE_LENGTH = {'inputs': 128, 'targets': 128}
_TASKS = [
'byt5_dakshina_single_word_translit_indic2latin.bn',
'byt5_dakshina_word_translit_latin2indic_lang_prefix.bn',
'byt5_gem_xsum',
'byt5_mc4.en',
'byt5_sigmorphon_2020_task1.ar',
'byt5_super_glue_boolq_v102',
'byt5_super_glue_cb_v102',
'byt5_super_glue_copa_v102',
'byt5_super_glue_multirc_v102',
'byt5_super_glue_record_v102',
'byt5_super_glue_rte_v102',
'byt5_super_glue_wic_v102',
'byt5_super_glue_wsc_v102_simple_eval',
'byt5_super_glue_wsc_v102_simple_train',
'byt5_tweetqa',
'byt5_wiki.en',
'byt5_wmt15_enfr_v003',
'byt5_wmt16_enro_v003',
'byt5_wmt_t2t_ende_v003',
'char_t5_mc4.en',
'mt5_dakshina_single_word_translit_indic2latin.bn',
'mt5_dakshina_word_translit_latin2indic_lang_prefix.bn',
'mt5_sigmorphon_2020_task0.dje'
]
_MIXTURES = [
'byt5_dak_wrdtrnslit_ind2lat',
'byt5_dak_wrdtrnslit_lat2ind',
'byt5_dak_wrdtrnslit_lat2ind_lp',
'byt5_glue_v002_proportional',
'byt5_mlqa_translate_train',
'byt5_mlqa_zeroshot',
'byt5_ner_multilingual',
'byt5_ner_zeroshot',
'byt5_pawsx_translate_train',
'byt5_pawsx_zeroshot',
'byt5_sigmorphon_2020_task0',
'byt5_sigmorphon_2020_task1',
'byt5_super_glue_v102_proportional',
'byt5_tydiqa',
'byt5_tydiqa_translate_train',
'byt5_tydiqa_zeroshot',
'byt5_wikilingua',
'byt5_xnli_translate_train',
'byt5_xnli_zeroshot',
'byt5_xquad_translate_train',
'byt5_xquad_zeroshot',
'mt5_dak_wrdtrnslit_ind2lat',
'mt5_dak_wrdtrnslit_lat2ind',
'mt5_dak_wrdtrnslit_lat2ind_lp',
'mt5_sigmorphon_2020_task0',
'mt5_sigmorphon_2020_task1'
]
class TasksTest(parameterized.TestCase):
@parameterized.parameters(((name,) for name in _TASKS))
def test_task(self, name):
task = TaskRegistry.get(name)
split = 'train' if 'train' in task.splits else 'validation'
logging.info('task=%s, split=%s', name, split)
ds = task.get_dataset(_SEQUENCE_LENGTH, split)
for d in ds:
logging.info(d)
break
@parameterized.parameters(((name,) for name in _MIXTURES))
def test_mixture(self, name):
mixture = MixtureRegistry.get(name)
logging.info('mixture=%s', name)
ds = mixture.get_dataset(_SEQUENCE_LENGTH, 'train')
for d in ds:
logging.info(d)
break
if __name__ == '__main__':
absltest.main()
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
r"""Given a task and its input length, return the max target length with packing.
Use a target length much longer than you'd expect given the number of packed
examples for the specified input length. Model will not learn well if target
lengths are too small.
"""
from absl import app
from absl import flags
from byt5 import tasks as byt5_tasks
from multilingual_t5 import tasks as mt5_tasks
import numpy as np
import t5.models.mesh_transformer as mesh_transformer
import tensorflow_datasets as tfds
FLAGS = flags.FLAGS
flags.DEFINE_string("task_or_mixture", None, "task/mixture name")
flags.DEFINE_integer("input_length", None, "Input length of tasks.")
flags.DEFINE_integer("num_sample_examples", 100,
"Set to None to load all examples.")
flags.DEFINE_string("vocab", None, "mt5 or byt5")
flags.DEFINE_list("splits", "train,dev,test", "Comma-separated list of splits.")
# Vocabs
VOCABS = {"byt5": byt5_tasks.DEFAULT_BYTE_OUTPUT_FEATURES,
"mt5": mt5_tasks.DEFAULT_OUTPUT_FEATURES}
# Splits
SPLITS = {"train": tfds.Split.TRAIN,
"dev": tfds.Split.VALIDATION,
"test": tfds.Split.TEST}
def compute_target_length(task_or_mixture,
input_len,
num_sample_examples,
vocab):
"""Given a task and a input length, write the max target lengths with packing.
Args:
task_or_mixture: string, task or mixture name.
input_len: int, input length.
num_sample_examples: int, number of sample examples.
vocab: string, vocab.
"""
target_lengths = []
for split in FLAGS.splits:
dummy_target_len = 512
ds = mesh_transformer.mesh_train_dataset_fn(
task_or_mixture,
sequence_length={"inputs": input_len, "targets": dummy_target_len},
vocabulary=vocab,
dataset_split=SPLITS[split])
if num_sample_examples:
ds = ds.take(num_sample_examples)
lengths = ([np.argmin(ex["targets_segmentation"])
for ex in ds.as_numpy_iterator()])
target_lengths.append(np.max(lengths))
# Print results
splits = FLAGS.splits + ["all"]
target_lengths = target_lengths + [np.max(target_lengths)]
for split, max_len in zip(splits, target_lengths):
print(f"Max target length for {split} is: {max_len} .")
def main(_):
if FLAGS.vocab not in VOCABS:
raise ValueError(f"Vocab of {FLAGS.vcoab} is not available")
compute_target_length(FLAGS.task_or_mixture,
FLAGS.input_length,
FLAGS.num_sample_examples,
FLAGS.vocab)
if __name__ == "__main__":
app.run(main)
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Add Tasks to registry."""
import functools
import random
from byt5.tasks import DEFAULT_BYTE_OUTPUT_FEATURES
from byt5.tasks import DEFAULT_MT5_OUTPUT_FEATURES
from byt5.tasks import DEFAULT_PREPROCESSORS
import numpy
import seqio
import t5.data
from t5.data import preprocessors
# Place downloaded data from https://sigmorphon.github.io/sharedtasks/2020 in
# the following directory.
SIGMORPHON_DIR = None
FEATURE_MAP = {
'byt5': DEFAULT_BYTE_OUTPUT_FEATURES,
'mt5': DEFAULT_MT5_OUTPUT_FEATURES
}
# ====================== SIGMORPHON-2020 TASK-1 ====================
# Task 1: Multilingual Grapheme-to-Phoneme Conversion
# Please see website https://sigmorphon.github.io/sharedtasks/2020/task1/
# for details.
def get_2020_task1_preprocessor(language):
return [
functools.partial(
preprocessors.preprocess_tsv,
inputs_format=f' {language} ' + '{0}',
targets_format='{1}',
num_fields=2),
]
def metrics_task1_2020(targets, predictions):
"""Computes word error rate and edit distance metrics."""
def edit_distance(x, y) -> int:
# Implementation from
# https://github.com/sigmorphon/2020/blob/master/task1/evaluation/evallib.py
idim = len(x) + 1
jdim = len(y) + 1
table = numpy.zeros((idim, jdim), dtype=numpy.uint8)
table[1:, 0] = 1
table[0, 1:] = 1
for i in range(1, idim):
for j in range(1, jdim):
if x[i - 1] == y[j - 1]:
table[i][j] = table[i - 1][j - 1]
else:
c1 = table[i - 1][j]
c2 = table[i][j - 1]
c3 = table[i - 1][j - 1]
table[i][j] = min(c1, c2, c3) + 1
return int(table[-1][-1])
# Word-level measures.
correct = 0
incorrect = 0
# Label-level measures.
total_edits = 0
total_length = 0
for gold, hypo in zip(targets, predictions):
edits = edit_distance(gold, hypo)
length = len(gold)
if edits == 0:
correct += 1
else:
incorrect += 1
total_edits += edits
total_length += length
wer = incorrect / (correct + incorrect)
ler = 100 * total_edits / total_length
return {'wer': wer, 'ler': ler}
langs = [
'arm', 'bul', 'fre', 'geo', 'hin', 'hun', 'ice', 'kor', 'lit', 'gre', 'ady',
'dut', 'jpn', 'rum', 'vie'
]
year = '2020'
task = 'task1'
data_dir = f'{SIGMORPHON_DIR}/{year}/{task}/data/'
for lang in langs:
for prefix, output_features in FEATURE_MAP.items():
seqio.TaskRegistry.add(
f'{prefix}_sigmorphon_{year}_{task}.{lang}',
source=seqio.TextLineDataSource(
split_to_filepattern={
'train': f'{data_dir}/train/{lang}_train.tsv',
'validation': f'{data_dir}/dev/{lang}_dev.tsv',
'test': f'{data_dir}/test/{lang}_test.tsv'}),
preprocessors=get_2020_task1_preprocessor(lang) + DEFAULT_PREPROCESSORS,
output_features=output_features,
metric_fns=[metrics_task1_2020])
for prefix in ['mt5', 'byt5']:
t5.data.MixtureRegistry.add(
f'{prefix}_sigmorphon_{year}_{task}',
[f'{prefix}_sigmorphon_{year}_{task}.{lang}' for lang in langs],
default_rate=1.)
# ====================== SIGMORPHON-2020 TASK-0 ====================
# Task 0: Typologically Diverse Morphological Inflection
# Please see website https://sigmorphon.github.io/sharedtasks/2020/task0/
# for details.
def get_2020_task0_preprocessor(language):
return [
functools.partial(
preprocessors.preprocess_tsv,
inputs_format=f'{language}' + ' {0} ' + 'form={2}',
targets_format='{1}',
num_fields=3),
]
def metrics_task0_2020(targets, predictions):
"""Calculates exact match and edit distance based metrics."""
def distance(str1, str2):
"""Levenshtein distance."""
# Implementation from
# https://github.com/sigmorphon2020/task0-data/blob/master/evaluate.py
m = numpy.zeros([len(str2) + 1, len(str1) + 1])
for x in range(1, len(str2) + 1):
m[x][0] = m[x - 1][0] + 1
for y in range(1, len(str1) + 1):
m[0][y] = m[0][y - 1] + 1
for x in range(1, len(str2) + 1):
for y in range(1, len(str1) + 1):
if str1[y - 1] == str2[x - 1]:
dg = 0
else:
dg = 1
m[x][y] = min(m[x - 1][y] + 1, m[x][y - 1] + 1, m[x - 1][y - 1] + dg)
return int(m[len(str2)][len(str1)])
correct, dist, total = 0., 0., 0.
for target, prediction in zip(targets, predictions):
if target == prediction:
correct += 1
dist += distance(target, prediction)
total += 1
return {
'accuracy': round(correct / total * 100, 2),
'distance': round(dist / total, 2)
}
surprise_lang_path_prefix = [
'SURPRISE-LANGUAGES/Afro-Asiatic/mlt', 'SURPRISE-LANGUAGES/Germanic/gsw',
'SURPRISE-LANGUAGES/Nilo-Sahan/dje', 'SURPRISE-LANGUAGES/Romance/frm',
'SURPRISE-LANGUAGES/Indo-Aryan/urd', 'SURPRISE-LANGUAGES/Uralic/kpv',
'SURPRISE-LANGUAGES/Sino-Tibetan/bod', 'SURPRISE-LANGUAGES/Germanic/nno',
'SURPRISE-LANGUAGES/Uralic/olo', 'SURPRISE-LANGUAGES/Romance/fur',
'SURPRISE-LANGUAGES/Romance/cat', 'SURPRISE-LANGUAGES/Afro-Asiatic/syc',
'SURPRISE-LANGUAGES/Algic/cre', 'SURPRISE-LANGUAGES/Turkic/kir',
'SURPRISE-LANGUAGES/Uralic/lud', 'SURPRISE-LANGUAGES/Uralic/udm',
'SURPRISE-LANGUAGES/Iranian/pus', 'SURPRISE-LANGUAGES/Romance/ast',
'SURPRISE-LANGUAGES/Germanic/gml', 'SURPRISE-LANGUAGES/Turkic/bak',
'SURPRISE-LANGUAGES/Indo-Aryan/hin', 'SURPRISE-LANGUAGES/Iranian/fas',
'SURPRISE-LANGUAGES/Niger-Congo/sna', 'SURPRISE-LANGUAGES/Romance/xno',
'SURPRISE-LANGUAGES/Romance/vec', 'SURPRISE-LANGUAGES/Dravidian/kan',
'SURPRISE-LANGUAGES/Afro-Asiatic/orm', 'SURPRISE-LANGUAGES/Turkic/uzb',
'SURPRISE-LANGUAGES/Uto-Aztecan/ood', 'SURPRISE-LANGUAGES/Turkic/tuk',
'SURPRISE-LANGUAGES/Iranian/tgk', 'SURPRISE-LANGUAGES/Romance/lld',
'SURPRISE-LANGUAGES/Turkic/kaz', 'SURPRISE-LANGUAGES/Indo-Aryan/ben',
'SURPRISE-LANGUAGES/Siouan/dak', 'SURPRISE-LANGUAGES/Romance/glg',
'SURPRISE-LANGUAGES/Turkic/kjh', 'SURPRISE-LANGUAGES/Turkic/crh',
'SURPRISE-LANGUAGES/Indo-Aryan/san', 'SURPRISE-LANGUAGES/Dravidian/tel',
'SURPRISE-LANGUAGES/Tungusic/evn', 'SURPRISE-LANGUAGES/Turkic/aze',
'SURPRISE-LANGUAGES/Uralic/vro', 'SURPRISE-LANGUAGES/Turkic/uig',
'SURPRISE-LANGUAGES/Australian/mwf'
]
development_lang_path_prefix = [
'DEVELOPMENT-LANGUAGES/germanic/swe', 'DEVELOPMENT-LANGUAGES/germanic/ang',
'DEVELOPMENT-LANGUAGES/oto-manguean/azg',
'DEVELOPMENT-LANGUAGES/uralic/vep', 'DEVELOPMENT-LANGUAGES/niger-congo/lin',
'DEVELOPMENT-LANGUAGES/niger-congo/nya',
'DEVELOPMENT-LANGUAGES/germanic/frr', 'DEVELOPMENT-LANGUAGES/uralic/vot',
'DEVELOPMENT-LANGUAGES/austronesian/mlg',
'DEVELOPMENT-LANGUAGES/oto-manguean/ctp',
'DEVELOPMENT-LANGUAGES/oto-manguean/otm',
'DEVELOPMENT-LANGUAGES/oto-manguean/ote',
'DEVELOPMENT-LANGUAGES/uralic/fin',
'DEVELOPMENT-LANGUAGES/oto-manguean/cpa',
'DEVELOPMENT-LANGUAGES/austronesian/mao',
'DEVELOPMENT-LANGUAGES/uralic/mdf', 'DEVELOPMENT-LANGUAGES/germanic/dan',
'DEVELOPMENT-LANGUAGES/niger-congo/gaa',
'DEVELOPMENT-LANGUAGES/oto-manguean/cly',
'DEVELOPMENT-LANGUAGES/uralic/mhr', 'DEVELOPMENT-LANGUAGES/niger-congo/zul',
'DEVELOPMENT-LANGUAGES/uralic/krl', 'DEVELOPMENT-LANGUAGES/niger-congo/kon',
'DEVELOPMENT-LANGUAGES/oto-manguean/czn',
'DEVELOPMENT-LANGUAGES/germanic/gmh', 'DEVELOPMENT-LANGUAGES/uralic/izh',
'DEVELOPMENT-LANGUAGES/austronesian/ceb',
'DEVELOPMENT-LANGUAGES/germanic/nob',
'DEVELOPMENT-LANGUAGES/austronesian/tgl',
'DEVELOPMENT-LANGUAGES/austronesian/hil',
'DEVELOPMENT-LANGUAGES/niger-congo/lug',
'DEVELOPMENT-LANGUAGES/niger-congo/sot',
'DEVELOPMENT-LANGUAGES/niger-congo/swa',
'DEVELOPMENT-LANGUAGES/germanic/isl',
'DEVELOPMENT-LANGUAGES/oto-manguean/pei',
'DEVELOPMENT-LANGUAGES/uralic/sme', 'DEVELOPMENT-LANGUAGES/germanic/nld',
'DEVELOPMENT-LANGUAGES/niger-congo/aka',
'DEVELOPMENT-LANGUAGES/germanic/eng',
'DEVELOPMENT-LANGUAGES/oto-manguean/zpv',
'DEVELOPMENT-LANGUAGES/uralic/est', 'DEVELOPMENT-LANGUAGES/uralic/liv',
'DEVELOPMENT-LANGUAGES/oto-manguean/xty',
'DEVELOPMENT-LANGUAGES/germanic/deu', 'DEVELOPMENT-LANGUAGES/uralic/myv'
]
year = '2020'
task = 'task0'
data_dir = f'{SIGMORPHON_DIR}/{year}/task0-data/'
langs = [
path_prefix.split('/')[-1]
for path_prefix in surprise_lang_path_prefix + development_lang_path_prefix
]
random.shuffle(langs)
path_prefixes = surprise_lang_path_prefix + development_lang_path_prefix
for prefix, output_features in FEATURE_MAP.items():
for path_prefix in path_prefixes:
lang = path_prefix.split('/')[-1]
split_to_filepattern = {
'train': f'{data_dir}/{path_prefix}.trn',
'validation': f'{data_dir}/{path_prefix}.dev',
'test': f'{data_dir}/GOLD-TEST/{lang}.tst',
}
seqio.TaskRegistry.add(
f'{prefix}_sigmorphon_{year}_{task}.{lang}',
source=seqio.TextLineDataSource(
split_to_filepattern=split_to_filepattern),
preprocessors=get_2020_task0_preprocessor(lang) + DEFAULT_PREPROCESSORS,
output_features=output_features,
metric_fns=[metrics_task0_2020])
seqio.TaskRegistry.add(
f'{prefix}_sigmorphon_{year}_{task}.all',
source=seqio.TextLineDataSource(
split_to_filepattern={
'test': f'{data_dir}/test.tsv',
'validation': f'{data_dir}/validation.tsv',}),
preprocessors=[preprocessors.preprocess_tsv,
*DEFAULT_PREPROCESSORS,],
output_features=output_features,
metric_fns=[metrics_task0_2020])
for prefix in ['mt5', 'byt5']:
t5.data.MixtureRegistry.add(
f'{prefix}_sigmorphon_{year}_{task}',
[f'{prefix}_sigmorphon_{year}_{task}.{lang}' for lang in langs],
default_rate=1.)
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
|
# Copyright 2023 The ByT5 Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
|
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Setup arco_era5.
This uses Apache Beam's recommended way to install non-python dependencies. This lets us install ecCodes for cfgrib on
Dataflow workers.
Please see the following documentation and examples for more:
- https://beam.apache.org/documentation/sdks/python-pipeline-dependencies/#nonpython
- https://github.com/apache/beam/blob/master/sdks/python/apache_beam/examples/complete/juliaset/setup.py
"""
import platform
import subprocess
from distutils.command.build import build as _build # type: ignore
from setuptools import setup, find_packages, Command
"""Install the ecCodes binary from ECMWF."""
CUSTOM_COMMANDS = [
cmd.split() for cmd in [
'apt-get update',
'apt-get --assume-yes install libeccodes-dev'
]
]
# This class handles the pip install mechanism.
class build(_build): # pylint: disable=invalid-name
"""A build command class that will be invoked during package install.
The package built using the current setup.py will be staged and later
installed in the worker using `pip install package'. This class will be
instantiated during install for this specific scenario and will trigger
running the custom commands specified.
"""
sub_commands = _build.sub_commands + [('CustomCommands', None)]
class CustomCommands(Command):
"""A setuptools Command class able to run arbitrary commands."""
def initialize_options(self):
pass
def finalize_options(self):
pass
def RunCustomCommand(self, command_list):
print('Running command: %s' % command_list)
p = subprocess.Popen(
command_list,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
# Can use communicate(input='y\n'.encode()) if the command run requires
# some confirmation.
stdout_data, _ = p.communicate()
print('Command output: %s' % stdout_data)
if p.returncode != 0:
raise RuntimeError(
'Command %s failed: exit code: %s' % (command_list, p.returncode))
def run(self):
# Only run on Linux, which is Dataflow's environment.
if 'Linux' not in platform.system():
return
for command in CUSTOM_COMMANDS:
self.RunCustomCommand(command)
setup(
name='arco_era5',
package_dir={'': 'src'},
packages=find_packages('src'),
author_email='[email protected]',
description="Analysis-Ready & Cloud-Optimized ERA5.",
version='0.1.0',
platforms=['darwin', 'linux'],
python_requires='>3.8, <3.11',
install_requires=[
'apache_beam[gcp]==2.40.0',
'pangeo-forge-recipes==0.9.1',
'pandas',
'gcsfs',
'cfgrib',
'immutabledict',
'xarray-beam',
'scipy',
],
tests_require=['pytest'],
cmdclass={
# Command class instantiated and run during pip install scenarios.
'build': build,
'CustomCommands': CustomCommands,
}
)
|
import cartopy.crs as ccrs
import cartopy.feature as cfeature
import matplotlib.pyplot as plt
import metview as mv
import numpy as np
from cartopy.mpl import ticker
from matplotlib import colors
from mpl_toolkits.axes_grid1 import axes_divider
__author__ = '[email protected]'
def plot_map(lats, lons,
x, label,
ax, cmap,
norm,
coastlines=False,
lakes=False,
rivers=False,
countries=False,
states=False,
counties=False,
provinces=False,
):
if counties:
counties_features = cfeature.NaturalEarthFeature(
category='cultural',
name='admin_2_counties_lakes',
scale='10m',
edgecolor='gray',
facecolor='none')
ax.add_feature(counties_features)
if states:
ax.add_feature(cfeature.STATES, edgecolor='darkgray')
if provinces:
provinces_features = cfeature.NaturalEarthFeature(
category='cultural',
name='admin_1_states_provinces_lines',
scale='10m',
facecolor='none')
ax.add_feature(provinces_features, edgecolor='gray')
if countries:
ax.add_feature(cfeature.BORDERS, edgecolor='black')
if rivers:
ax.add_feature(cfeature.RIVERS, edgecolor='blue')
if lakes:
ax.add_feature(cfeature.LAKES, edgecolor='black', facecolor='none')
if coastlines:
ax.add_feature(cfeature.COASTLINE, edgecolor='black')
lon_we = (lons + 180) % 360 - 180
ax.set_extent([lon_we.min(), np.ceil(lon_we.max()), lats.min(), np.ceil(lats.max())], crs=ccrs.PlateCarree())
ax.set_xticks(np.linspace(lon_we.min(), np.ceil(lon_we.max()), 7), crs=ccrs.PlateCarree())
ax.set_yticks(np.linspace(lats.min(), np.ceil(lats.max()), 7), crs=ccrs.PlateCarree())
lon_formatter = ticker.LongitudeFormatter(zero_direction_label=True, degree_symbol="", number_format=".1f")
lat_formatter = ticker.LatitudeFormatter(degree_symbol="", number_format=".1f")
ax.xaxis.set_major_formatter(lon_formatter)
ax.yaxis.set_major_formatter(lat_formatter)
p = ax.pcolormesh(lons, lats, x,
transform=ccrs.PlateCarree(),
cmap=cmap,
norm=norm)
ax.set_title(label)
ax.set_xlabel('')
ax.set_ylabel('')
return p
def plot_barbs(lats, lons, u, v, ax, skip=4):
p = ax.barbs(
lons[::skip], lats[::skip], u[::skip, ::skip], v[::skip, ::skip],
color='k',
transform=ccrs.PlateCarree(),
)
return p
def plot_shaded_with_barbs(plot_ds,
shading_variable='si10',
label="Wind Speed (m/s)",
cmap='viridis',
plot_wind_barbs=True,
barb_skip=4,
scalevar=1.0, add_offset=0.0,
coastlines=True,
lakes=False,
rivers=False,
countries=False,
states=False,
counties=False,
provinces=False,
uvar="u10",
vvar="v10",
figsize=(12, 15)):
fig = plt.figure(figsize=figsize)
ax = fig.add_subplot(2, 1, 1, projection=ccrs.PlateCarree())
ax.set_global()
divider = axes_divider.make_axes_locatable(ax)
min_bound = plot_ds[shading_variable].min() * scalevar + add_offset
max_bound = plot_ds[shading_variable].max() * scalevar + add_offset
norm = colors.Normalize(min_bound, max_bound)
im = plot_map(plot_ds.latitude, plot_ds.longitude,
(plot_ds[shading_variable] * scalevar + add_offset),
label, ax, cmap=cmap, norm=norm,
coastlines=coastlines,
lakes=lakes,
rivers=rivers,
countries=countries,
states=states,
provinces=provinces,
counties=counties,
)
if plot_wind_barbs:
sp = plot_barbs(plot_ds.latitude, plot_ds.longitude,
plot_ds[uvar].values, plot_ds[vvar].values,
ax, skip=barb_skip)
cax = divider.append_axes("right", size="2%", pad=0.05,
axes_class=plt.Axes)
fig.colorbar(im, cax=cax)
def shaded_plot(fieldset, **kwargs):
# The shortName of the field we want to plot
shortName = kwargs.get("shortName", "ws")
# True to overlay the vector winds
plotWind = kwargs.get("plotWind", False)
level = kwargs.get("level", 137) # The level to plot
# Line with coordinates [Lat1, Lon1, Lat2, Lon2]
line = kwargs.get("line", [0, 0, 0, 0])
plotLine = kwargs.get("plotLine", False) # True to plot the line
# Rescale the variable by scaleFactor
scaleFactor = kwargs.get("scaleFactor", 1.0)
# Adjust the rescaled variable by a constant factor
scaleBias = kwargs.get("scaleBias", 0.0)
# Contour style to use
styleName = kwargs.get("styleName", "sh_all_f03t70_beauf")
# Spacing Latitude labels in degrees
coastLatSpacing = kwargs.get("coastLatSpacing", 15)
# Spacing of longitude labels in degrees
coastLonSpacing = kwargs.get("coastLonSpacing", 20)
mapAdministrativeBoundaries = kwargs.get(
"mapAdministrativeBoundaries", "off") # "On" to plot states/provinces boundaries
mapAdministrativeBoundariesColour = kwargs.get(
"mapAdministrativeBoundariesColour", "automatic") # Administrative boundary color
mapAdministrativeBoundariesCountriesList = kwargs.get(
"mapAdministrativeBoundariesCountriesList",
[]) # List of countries to plot administrative boundaries using ISO 3166-1 alpha-3 codes
mapAdministrativeBoundariesStyle = kwargs.get(
"mapAdministrativeBoundariesStyle", "dash") # Administrative (states/provinces) boundary style
mapAdministrativeBoundariesThickness = kwargs.get(
"mapAdministrativeBoundariesThickness", 1) # Administrative boundary thickness
mapAreaName = kwargs.get("mapAreaName", "") # Plot a predefined region, overrides mapCorners
mapBoundaries = kwargs.get("mapBoundaries", "on") # National boundaries
mapBoundariesColour = kwargs.get("mapBoundariesColour", "automatic") # National boundary color
mapBoundariesThickness = kwargs.get("mapBoundariesThickness", 1)
mapCoastLandShade = kwargs.get("mapCoastLandShade", "off") # On to shade the land
mapCoastSeaShade = kwargs.get("mapCoastSeaShade", "off") # On to shade the ocean
mapCoastLineThickness = kwargs.get("mapCoastLineThickness", 1)
mapCities = kwargs.get("mapCities", "off") # On to plot the capitals of each country
mapCitiesFontSize = kwargs.get("mapCitiesFontSize", 2.5)
mapCitiesMarkerHeight = kwargs.get("mapCitiesMarkerHeight", 0.7)
mapCorners = kwargs.get("mapCorners", [-90, -180, 90, 180]) # Lat1, Lon1, Lat2, Lon2 of a plotting region
mapGrid = kwargs.get("mapGrid", "off") # On to plot lat/lon grid lines
mapLabelHeight = kwargs.get("mapLabelHeight", 0.4)
mapRivers = kwargs.get("mapRivers", "off") # On to plot major rivers
outputWidth = kwargs.get("outputWidth", 1800)
textFontSize = kwargs.get("textFontSize", 1.0)
unitString = kwargs.get("unitString", "")
windDensity = kwargs.get("windDensity", 2.5)
windFieldType = kwargs.get("windFieldType", "arrows") # Choices are "flags", "arrows", "streamlines"
plot_shaded = fieldset.select(shortName=shortName,
level=level) * scaleFactor + scaleBias
plot_u = None
plot_v = None
plot_uv = None
if plotWind:
plot_u = fieldset.select(shortName='u', level=level)
plot_v = fieldset.select(shortName='v', level=level)
plot_uv = mv.merge(plot_u, plot_v)
contours = mv.mcont(legend="on",
contour_automatics_settings="style_name",
contour_style_name=styleName)
coastlines = mv.mcoast(
map_administrative_boundaries=mapAdministrativeBoundaries,
map_administrative_boundaries_countries_list=mapAdministrativeBoundariesCountriesList,
map_administrative_boundaries_colour=mapAdministrativeBoundariesColour,
map_administrative_boundaries_thickness=mapAdministrativeBoundariesThickness,
map_administrative_boundaries_style=mapAdministrativeBoundariesStyle,
map_boundaries=mapBoundaries,
map_boundaries_colour=mapBoundariesColour,
map_boundaries_thickness=mapBoundariesThickness,
map_cities=mapCities,
map_cities_font_size=mapCitiesFontSize,
map_cities_marker_height=mapCitiesMarkerHeight,
map_coastline_colour="charcoal",
map_coastline_land_shade=mapCoastLandShade,
map_coastline_land_shade_colour="beige",
map_coastline_sea_shade=mapCoastSeaShade,
map_coastline_sea_shade_colour="RGB(0.8178,0.9234,0.9234)",
map_coastline_thickness=mapCoastLineThickness,
map_disputed_boundaries="on",
map_disputed_boundaries_thickness=mapBoundariesThickness,
map_grid=mapGrid,
map_grid_line_style="dash",
map_grid_colour="navy",
map_grid_latitude_increment=coastLatSpacing,
map_grid_longitude_increment=coastLonSpacing,
map_label_colour="black",
map_label_font_style="bold",
map_label_height=mapLabelHeight,
map_rivers=mapRivers,
)
legend = mv.mlegend(
legend_text_font_size=0.5
)
if mapAreaName:
view = mv.geoview(
area_mode="name",
area_name=mapAreaName,
coast=coastlines
)
else:
view = mv.geoview(
map_area_definition="corners",
area=mapCorners,
coast=coastlines
)
# define wind plotting
wdef = mv.mwind(
wind_thinning_mode="density",
wind_density=windDensity,
wind_field_type=windFieldType,
)
lon_arr = []
lat_arr = []
for i in range(0, len(line), 2):
lat_arr.append(line[i])
lon_arr.append(line[i + 1])
vis_line = mv.input_visualiser(
input_plot_type="geo_points",
input_longitude_values=lon_arr,
input_latitude_values=lat_arr,
)
graph_line = mv.mgraph(graph_line_colour="black", graph_line_thickness=4)
# set-up the title
field_level = "<grib_info key='level'/>"
field_name = "<grib_info key='name'/>"
field_shortName = "<grib_info key='shortName'/>"
field_valid = "<grib_info key='valid-date' format='%a %d %b %Y %H UTC'/>"
filter_valid = "<grib_info key='valid-date' format='%a %d %b %Y %H UTC' where='shortName=ws'/>"
field_units = "<grib_info key='units'/>"
filter_units = "<grib_info key='units' where='shortName=ws'/>"
filter_level = "<grib_info key='level' where='shortName=ws'/>"
if unitString:
title_text = "ERA5 {} ({}) for {} on level {}".format(
field_name, unitString, field_valid, field_level)
filter_text = "ERA5 Wind ({}) {} {}".format(
unitString, filter_valid, filter_level)
else:
title_text = "ERA5 {} ({}) for {} on level {}".format(
field_name, field_units, field_valid, field_level)
filter_text = "ERA5 Wind ({}) {} on level {}".format(
filter_units, filter_valid, filter_level)
title = mv.mtext(
text_font_size=textFontSize,
text_lines=[
title_text,
],
text_colour="CHARCOAL",
)
wind_title = mv.mtext(
text_font_size=textFontSize,
text_lines=[
filter_text,
]
)
mv.setoutput("jupyter", output_width=outputWidth)
if plotWind:
if plotLine:
mv.plot(view, plot_shaded, contours,
plot_uv, wdef, vis_line,
graph_line, legend, wind_title)
else:
mv.plot(view, plot_shaded, contours,
plot_uv, wdef, legend, wind_title)
else:
if plotLine:
mv.plot(view, plot_shaded, contours,
vis_line, graph_line, legend, title)
else:
mv.plot(view, plot_shaded, contours,
legend, title)
del plot_shaded
del plot_u
del plot_v
del plot_uv
|
#!/usr/bin/env python
"""Script to merge AR ML datasets into CO ML dataset.
This script contains the Metview workflow that will merge the
AR ML datasets into a single ML dataset. It will also create several
commonly used derived variables (u/v winds, dewpoint temperature, relative humidity,
geopotential, and pressure) on the model levels). This script produces
a Gaussian gridded dataset and a regular lat-lon dataset.
"""
import xarray
def attribute_fix(ds):
"""Needed to fix a low-level bug in ecCodes.
Sometimes, shortNames get overloaded in ecCodes's table.
To eliminate ambiguity in their string matching, we
force ecCodes to make use of the paramId, which is a
consistent source-of-truth.
"""
for var in ds:
attrs = ds[var].attrs
result = attrs.pop('GRIB_cfName', None)
result = attrs.pop('GRIB_cfVarName', None)
result = attrs.pop('GRIB_shortName', None)
ds[var].attrs.update(attrs)
return ds
def compute_gg_ll_dataset(ml_surface, ml_wind, ml_moisture, datestring):
"""Merges/processes AR ML dataset to a CO ML dataset.
This function takes a datestamp and the three AR model-level ERA5
datasets to produce a unified model-level dataset on a Gaussian Grid
and a regular lat-lon grid for a single hour.
"""
import metview as mv
surface_slice = ml_surface.sel(time=slice(datestring,datestring)).compute()
wind_slice = ml_wind.sel(time=slice(datestring,datestring)).compute()
moisture_slice = ml_moisture.sel(time=slice(datestring,datestring)).compute()
# Fix the fieldsets
# WARNING: Metview creates temporary files for each fieldset variable. This
# can use a lot of local disk space. It's important to delete fieldset
# variables once they are no longer necessary to free up disk space.
wind_fieldset = mv.dataset_to_fieldset(attribute_fix(wind_slice).squeeze())
surface_fieldset = mv.dataset_to_fieldset(attribute_fix(surface_slice).squeeze())
moist_fieldset = mv.dataset_to_fieldset(attribute_fix(moisture_slice).squeeze())
# Translate spectral surface fields into Gaussian Grid
surface_gg = mv.read(data=surface_fieldset,grid='N320')
surface_gg.describe()
lnsp_gg = surface_gg.select(shortName="lnsp")
zs_gg = surface_gg.select(shortName="z")
# Compute pressure values at model levels
pres_gg = mv.unipressure(surface_gg.select(shortName="lnsp"))
# Convert spectral model level data to Gaussian Grids
wind_gg = mv.read(data=wind_fieldset,grid='N320')
t_gg = wind_gg.select(shortName='t')
q_gg = moist_fieldset.select(shortName='q')
r_gg = mv.relative_humidity_from_specific_humidity(t_gg,q_gg,lnsp_gg)
td_gg = mv.dewpoint_from_specific_humidity(q_gg,lnsp_gg)
moist_fieldset = mv.merge(moist_fieldset,r_gg,td_gg)
# Deleting unnecessary fieldset variables to save space.
del r_gg
del td_gg
# Compute geopotential on model levels
zm_gg = mv.mvl_geopotential_on_ml(t_gg, q_gg, lnsp_gg, zs_gg)
pz_fieldset = mv.merge(pres_gg, zm_gg)
# Merging fieldset variables creates a new temporary file, so we should delete
# the individual variables now to save space.
del surface_fieldset
del t_gg
del q_gg
del lnsp_gg
del zs_gg
del pres_gg
del zm_gg
# Compute the u/v wind elements from d/vo and then translate to a Gaussian grid
uv_wind_spectral = mv.uvwind(data=wind_fieldset,truncation=639)
uv_wind_gg = mv.read(data=uv_wind_spectral,grid='N320')
del uv_wind_spectral
del wind_fieldset
u_wind_gg = uv_wind_gg.select(shortName='u')
v_wind_gg = uv_wind_gg.select(shortName='v')
speed_gg = mv.speed(u_wind_gg,v_wind_gg)
del u_wind_gg
del v_wind_gg
# The next step creates the largest temporary file in this workflow since it's bringing
# all of the fieldset variables together. We'll delete the individual fieldsets once the
# merge is complete to save space.
gg_fieldset = mv.merge(wind_gg, speed_gg, uv_wind_gg, pz_fieldset, moist_fieldset)
del wind_gg
del speed_gg
del uv_wind_gg
del pz_fieldset
del moist_fieldset
print("About to gg_fieldset.to_dataset()")
gg_dataset = gg_fieldset.to_dataset()
# Interpolate the Gaussian Grid fieldset to a regular lat-lon grid
ll_fieldset = mv.read(data=gg_fieldset, grid=[0.25, 0.25])
ll_dataset = ll_fieldset.to_dataset()
# To err on the side of caution, we're deleting all of the remaining
# fieldset variables to save disk space.
del surface_gg
del ll_fieldset
del gg_fieldset
return gg_dataset, ll_dataset
def main():
ml_surface = xarray.open_zarr(
'gs://gcp-public-data-arco-era5/co/single-level-surface.zarr/',
chunks={'time': 48},
consolidated=True,
)
ml_wind = xarray.open_zarr(
'gs://gcp-public-data-arco-era5/co/model-level-wind.zarr/',
chunks={'time': 48},
consolidated=True,
)
ml_moisture = xarray.open_zarr(
'gs://gcp-public-data-arco-era5/co/model-level-moisture.zarr/',
chunks={'time': 48},
consolidated=True,
)
datestring="2017-10-09T06"
gg_dataset, ll_dataset = compute_gg_ll_dataset(ml_surface, ml_wind, ml_moisture, datestring)
print(gg_dataset)
if __name__ == "__main__":
main()
|
# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
import configparser
import datetime
import json
import logging
import os
import re
import subprocess
import signal
import typing as t
from google.cloud import secretmanager
DIRECTORY = "/weather/config_files"
FIELD_NAME = "date"
PROJECT = os.environ.get("PROJECT")
REGION = os.environ.get("REGION")
BUCKET = os.environ.get("BUCKET")
SDK_CONTAINER_IMAGE = os.environ.get("SDK_CONTAINER_IMAGE")
MANIFEST_LOCATION = os.environ.get("MANIFEST_LOCATION")
API_KEY_PATTERN = re.compile(r'^API_KEY_\d+$')
API_KEY_LIST = []
logger = logging.getLogger(__name__)
class ConfigArgs(t.TypedDict):
"""A class representing the configuration arguments for the new_config_file
function.
Attributes:
co_file (bool): True if the configuration file is a 'CO' type file, False
otherwise.
year_wise_date (bool): True if the configuration file contains 'year',
'month' and 'day', False otherwise.
first_day_first_prev (datetime.date): The first day of the first previous month.
last_day_first_prev (datetime.date): The last day of the first previous month.
first_day_third_prev (datetime.date): The first day of the third previous month.
last_day_third_prev (datetime.date): The last day of the third previous month.
sl_year (str): The year of the third previous month in 'YYYY' format.
sl_month (str): The month of the third previous month in 'MM' format.
"""
co_file: bool
year_wise_date: bool
first_day_first_prev: datetime.date
last_day_first_prev: datetime.date
first_day_third_prev: datetime.date
last_day_third_prev: datetime.date
sl_year: str
sl_month: str
class MonthDates(t.TypedDict):
"""A class representing the first and third previous month's dates.
Attributes:
first_day_first_prev (datetime.date): The first day of the first previous month.
last_day_first_prev (datetime.date): The last day of the first previous month.
first_day_third_prev (datetime.date): The first day of the third previous month.
last_day_third_prev (datetime.date): The last day of the third previous month.
sl_year (str): The year of the third previous month in 'YYYY' format.
sl_month (str): The month of the third previous month in 'MM' format.
"""
first_day_first_prev: datetime.date
last_day_first_prev: datetime.date
first_day_third_prev: datetime.date
last_day_third_prev: datetime.date
sl_year: str
sl_month: str
def new_config_file(config_file: str, field_name: str, additional_content: str,
config_args: ConfigArgs) -> None:
"""Modify the specified configuration file with new values.
Parameters:
config_file (str): The path to the configuration file to be modified.
field_name (str): The name of the field to be updated with the new value.
additional_content (str): The additional content to be added under the
'[selection]' section.
config_args (ConfigArgs): A dictionary containing the configuration arguments
as key-value pairs.
"""
# Unpack the values from config_args dictionary
co_file = config_args["co_file"]
year_wise_date = config_args["year_wise_date"]
first_day_first_prev = config_args["first_day_first_prev"]
last_day_first_prev = config_args["last_day_first_prev"]
first_day_third_prev = config_args["first_day_third_prev"]
last_day_third_prev = config_args["last_day_third_prev"]
sl_year = config_args["sl_year"]
sl_month = config_args["sl_month"]
config = configparser.ConfigParser()
config.read(config_file)
if year_wise_date:
config.set("selection", "year", sl_year)
config.set("selection", "month", sl_month)
config.set("selection", "day", "all")
else:
if co_file:
config.set("selection", field_name,
f"{first_day_first_prev}/to/{last_day_first_prev}")
else:
config.set("selection", field_name,
f"{first_day_third_prev}/to/{last_day_third_prev}")
sections_list = additional_content.split("\n\n")
for section in sections_list[:-1]:
sections = section.split("\n")
new_section_name = sections[0].strip()
config.add_section(new_section_name)
api_url_name, api_url_value = sections[1].split("=")
config.set(new_section_name, api_url_name.strip(), api_url_value.strip())
api_key_name, api_key_value = sections[2].split("=")
config.set(new_section_name, api_key_name.strip(), api_key_value.strip())
with open(config_file, "w") as file:
config.write(file, space_around_delimiters=False)
def get_month_range(date: datetime.date) -> t.Tuple[datetime.date, datetime.date]:
"""Return the first and last date of the previous month based on the input date.
Parameters:
date (datetime.date): The input date.
Returns:
tuple: A tuple containing the first and last date of the month as
datetime.date objects.
"""
last_day = date.replace(day=1) - datetime.timedelta(days=1)
first_day = last_day.replace(day=1)
return first_day, last_day
def get_previous_month_dates() -> MonthDates:
"""Return a dictionary containing the first and third previous month's dates from
the current date.
Returns:
dict: A dictionary containing the following key-value pairs:
- 'first_day_first_prev': The first day of the first previous month
(datetime.date).
- 'last_day_first_prev': The last day of the first previous month
(datetime.date).
- 'first_day_third_prev': The first day of the third previous month
(datetime.date).
- 'last_day_third_prev': The last day of the third previous month
(datetime.date).
- 'sl_year': The year of the third previous month in 'YYYY' format (str).
- 'sl_month': The month of the third previous month in 'MM' format (str).
"""
today = datetime.date.today()
# Calculate the correct previous month considering months from 1 to 12
prev_month = today.month + 10 if today.month < 3 else today.month - 2
third_prev_month = today.replace(month=prev_month)
first_prev_month = today.replace(month=today.month)
first_day_third_prev, last_day_third_prev = get_month_range(third_prev_month)
first_day_first_prev, last_day_first_prev = get_month_range(first_prev_month)
first_date_third_prev = first_day_third_prev
sl_year, sl_month = str(first_date_third_prev)[:4], str(first_date_third_prev)[5:7]
return {
'first_day_first_prev': first_day_first_prev,
'last_day_first_prev': last_day_first_prev,
'first_day_third_prev': first_day_third_prev,
'last_day_third_prev': last_day_third_prev,
'sl_year': sl_year,
'sl_month': sl_month,
}
def update_config_files(directory: str, field_name: str,
additional_content: str) -> None:
"""Update the configuration files in the specified directory.
Parameters:
directory (str): The path to the directory containing the configuration files.
field_name (str): The name of the field to be updated with the new value.
additional_content (str): The additional content to be added under the
'[selection]' section.
"""
dates_data = get_previous_month_dates()
config_args = {
"first_day_first_prev": dates_data['first_day_first_prev'],
"last_day_first_prev": dates_data['last_day_first_prev'],
"first_day_third_prev": dates_data['first_day_third_prev'],
"last_day_third_prev": dates_data['last_day_third_prev'],
"sl_year": dates_data['sl_year'],
"sl_month": dates_data['sl_month'],
}
for filename in os.listdir(directory):
config_args["year_wise_date"] = config_args["co_file"] = False
if filename.endswith(".cfg"):
if "lnsp" in filename or "zs" in filename or "sfc" in filename:
config_args["year_wise_date"] = True
if "hourly" in filename:
config_args["co_file"] = True
config_file = os.path.join(directory, filename)
# Pass the data as keyword arguments to the new_config_file function
new_config_file(config_file, field_name, additional_content,
config_args=config_args)
def get_secret(secret_key: str) -> dict:
"""Retrieve the secret value from the Google Cloud Secret Manager.
Parameters:
api_key (str): The name or identifier of the secret in the Google
Cloud Secret Manager.
Returns:
dict: A dictionary containing the retrieved secret data.
"""
client = secretmanager.SecretManagerServiceClient()
response = client.access_secret_version(request={"name": secret_key})
payload = response.payload.data.decode("UTF-8")
secret_dict = json.loads(payload)
return secret_dict
if __name__ == "__main__":
for env_var in os.environ:
if API_KEY_PATTERN.match(env_var):
api_key_value = os.environ.get(env_var)
API_KEY_LIST.append(api_key_value)
additional_content = ""
for count, secret_key in enumerate(API_KEY_LIST):
secret_key_value = get_secret(secret_key)
additional_content += f'parameters.api{count}\n\
api_url={secret_key_value["api_url"]}\napi_key={secret_key_value["api_key"]}\n\n'
current_day = datetime.date.today()
job_name = f"wx-dl-arco-era5-{current_day.month}-{current_day.year}"
# TODO(#373): Update the command once `--async` keyword added in weather-dl.
command = (
f'python weather_dl/weather-dl /weather/config_files/*.cfg --runner '
f'DataflowRunner --project {PROJECT} --region {REGION} --temp_location '
f'"gs://{BUCKET}/tmp/" --disk_size_gb 260 --job_name {job_name} '
f'--sdk_container_image {SDK_CONTAINER_IMAGE} '
f'--manifest-location {MANIFEST_LOCATION} --experiment use_runner_v2'
)
update_config_files(DIRECTORY, FIELD_NAME, additional_content)
stop_on_log = 'JOB_STATE_RUNNING'
process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
with process.stdout:
try:
for line in iter(process.stdout.readline, b''):
log_message = line.decode("utf-8").strip()
print(log_message)
if stop_on_log in log_message:
print(f'Stopping subprocess as {stop_on_log}')
os.killpg(os.getpgid(process.pid), signal.SIGTERM)
except subprocess.CalledProcessError as e:
logger.error(
f'Failed to execute dataflow job due to {e.stderr.decode("utf-8")}'
)
|
# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
import fsspec
import pandas as pd
import typing as t
BUCKET = "gcp-public-data-arco-era5"
START_YEAR = 1979
END_YEAR = 2022
def list_files_in_directory(bucket_name: str, directory_prefix: str) -> t.List[str]:
"""List files in a directory of a cloud storage bucket using fsspec.
Args:
bucket_name (str): The name of the cloud storage bucket.
directory_prefix (str): The prefix of the directory.
Returns:
List[str]: A list of file names in the directory.
"""
fs = fsspec.filesystem('gs')
files = fs.ls(f'{bucket_name}/{directory_prefix}')
return [file[len(bucket_name) + 1:] for file in files]
def find_extra_files(directory_files: t.List[str], desired_files: t.List[str]
) -> t.List[str]:
"""Returns a list of files that are in the directory but not in the desired list.
Args:
directory_files (List[str]): List of files in the directory.
desired_files (List[str]): List of desired file names.
Returns:
List[str]: A list of file names that are extra in the directory.
"""
return list(set(directory_files) - set(desired_files))
def generate_daily_file_names(year: int, chunks: t.List) -> t.List[str]:
"""Generate a list of daily file names for a given year.
Args:
year (int): The year for which to generate file names.
chunks (List): A list of the daily file chunks.
Returns:
List[str]: A list of generated daily file names.
"""
generated_files = []
date_range = pd.date_range(f'{year}-01-01', f'{year+1}-01-01', freq='D')
for date in date_range[:-1]:
for chunk in chunks:
generated_files.append(
f'raw/ERA5GRIB/HRES/Daily/{year}/{date:%Y%m%d}_hres_{chunk}.grb2')
return generated_files
def generate_monthly_file_names(year: int,
monthly_chunks: t.List, monthly_chunks_pcp: t.List,
monthly_chunks_soil: t.List) -> t.List[str]:
"""Generates a list of desired monthly file names for a given year."""
monthly_dates = [f"{year}{month:02d}" for month in range(1, 13)]
generated_files = []
for month in monthly_dates:
for chunk in monthly_chunks:
generated_files.append(
f'raw/ERA5GRIB/HRES/Month/{year}/{month}_hres_{chunk}.grb2')
for chunk in monthly_chunks_pcp:
generated_files.append(
f"raw/ERA5GRIB/HRES/Month/{year}/{month}_hres_pcp.grb2_surface_{chunk}.grib")
for chunk in monthly_chunks_soil:
generated_files.append(
f"raw/ERA5GRIB/HRES/Month/{year}/{month}_hres_soil.grb2_depthBelowLandLayer_{chunk}.grib")
generated_files.append(
f'raw/ERA5GRIB/HRES/Month/{year}/{month}_hres_soil.grb2_surface_tsn.grib')
return generated_files
def validate_and_report_missing_files(bucket_name: str, directory_prefix: str,
desired_files: t.List[str]):
"""Validates and reports missing files in the specified directory for a given year.
Args:
bucket_name (str): The name of the cloud storage bucket.
directory_prefix (str): The prefix of the directory.
desired_files (List[str]): List of desired file names.
"""
try:
actual_files = list_files_in_directory(bucket_name, directory_prefix)
extra_files = find_extra_files(actual_files, desired_files)
# Here first element of actual_files is directory_prefix itself
# so we aren't considered it.
# Like if directory_prefix = 'raw/ERA5GRIB/HRES/Daily/2002' then
# actual_files[0] = 'raw/ERA5GRIB/HRES/Daily/2002'.
if len(extra_files) > 1:
print(f"Extra files in {directory_prefix}:")
for file in extra_files[1:]:
print(file)
else:
print(f"There is no extra files in {directory_prefix}.")
except Exception as e:
print(f"An error occurred: {e}")
if __name__ == '__main__':
for year in range(START_YEAR, END_YEAR + 1):
# Process daily files
daily_chunks = ['dve', 'o3q', 'qrqs', 'tw', 'tuvw']
directory_prefix_daily = f"raw/ERA5GRIB/HRES/Daily/{year}/"
desired_files_daily = generate_daily_file_names(year, daily_chunks)
validate_and_report_missing_files(BUCKET, directory_prefix_daily,
desired_files_daily)
# Process monthly files
monthly_chunks = ['cape', 'cisst', 'lnsp', 'pcp', 'rad', 'sfc', 'soil', 'tcol',
'zs']
monthly_chunks_pcp = ['cp', 'crr', 'csf', 'csfr', 'es', 'lsf', 'lsp', 'lspf',
'lsrr', 'lssfr', 'ptype', 'rsn', 'sd', 'sf', 'smlt', 'tp']
monthly_chunks_soil = ['istl1', 'istl2', 'istl3', 'istl4', 'stl1', 'stl2',
'stl3', 'stl4', 'swvl1', 'swvl2', 'swvl3', 'swvl4']
directory_prefix_monthly = f"raw/ERA5GRIB/HRES/Month/{year}/"
desired_files_monthly = generate_monthly_file_names(
year, monthly_chunks, monthly_chunks_pcp, monthly_chunks_soil)
validate_and_report_missing_files(BUCKET, directory_prefix_monthly,
desired_files_monthly)
print("Finished")
|
import configparser
import datetime
import json
import os
import tempfile
import unittest
from unittest.mock import patch, MagicMock
from fetch import (
new_config_file,
get_month_range,
get_previous_month_dates,
update_config_files,
get_secret,
)
class TestFetchFunctions(unittest.TestCase):
def setUp(self):
# Create a temporary directory for testing
self.temp_dir = tempfile.TemporaryDirectory()
self.config_file = os.path.join(self.temp_dir.name, "test_config.cfg")
with open(self.config_file, "w") as file:
file.write(
"[parameters]\nclient=cds\ndataset=reanalysis-era5-complete\n\
target_path=gs://gcp-public-data-arco-era5/raw/ERA5GRIB/HRES\
/Daily/{date:%%Y/%%Y%%m%d}_hres_dve.grb2\npartition_keys=\n\t\
dates\n\n[selection]\nclass=ea\nstream=oper\nexpver=1\ntype=an\n\
levtype=ml\nlevelist=1/to/137\ndate=1979-01-01/to/2023-03-31\n\
time=00/to/23\nparam=138/155\n"
)
self.config_args = {
"first_day_first_prev": datetime.date(2023, 7, 1),
"last_day_first_prev": datetime.date(2023, 7, 31),
"first_day_third_prev": datetime.date(2023, 5, 1),
"last_day_third_prev": datetime.date(2023, 5, 31),
"sl_year": "2023",
"sl_month": "05",
'single_level_file': False,
'co_file': False
}
self.additional_content = "[parameters.test]\napi_url=test_url\napi_key=\
test_key\n\n"
def tearDown(self):
os.remove(self.config_file)
os.rmdir(self.temp_dir.name)
self.temp_dir.cleanup()
def test_new_config_file(self):
section_name = 'parameters.test'
section_api_url = 'test_url'
section_api_key = 'test_key'
additional_content = f'{section_name}\napi_url={section_api_url}\n\
api_key={section_api_key}\n\n'
new_config_file(self.config_file, "date", additional_content, self.config_args)
config = configparser.ConfigParser()
config.read(self.config_file)
self.assertIn(section_name, config.sections())
self.assertEqual(
config.get("selection", "date"),
f'{self.config_args["first_day_third_prev"]}/to/{self.config_args["last_day_third_prev"]}',
)
self.assertEqual(config.get(section_name, 'api_url'),
section_api_url)
self.assertEqual(config.get(section_name, 'api_key'),
section_api_key)
def test_new_config_file_with_co_file(self):
self.config_args["co_file"] = True
self.config_args["single_level_file"] = False
new_config_file(
self.config_file, "date", self.additional_content, self.config_args)
config = configparser.ConfigParser()
config.read(self.config_file)
self.assertEqual(
config.get('selection', 'date'),
f'{self.config_args["first_day_first_prev"]}/to/{self.config_args["last_day_first_prev"]}'
)
def test_new_config_file_with_single_level_file(self):
self.config_args["co_file"] = False
self.config_args["single_level_file"] = True
new_config_file(
self.config_file, "date", self.additional_content, self.config_args)
config = configparser.ConfigParser()
config.read(self.config_file)
self.assertEqual(config.get('selection', 'year'), self.config_args["sl_year"])
self.assertEqual(config.get('selection', 'month'), self.config_args["sl_month"])
self.assertEqual(config.get('selection', 'day'), 'all')
def test_get_month_range(self):
# Test get_month_range function
first_day, last_day = get_month_range(datetime.date(2023, 7, 18))
self.assertEqual(first_day, datetime.date(2023, 6, 1))
self.assertEqual(last_day, datetime.date(2023, 6, 30))
def test_get_previous_month_dates(self):
# Test get_previous_month_dates function
prev_month_data = get_previous_month_dates()
self.assertIn("first_day_first_prev", prev_month_data)
self.assertIn("last_day_first_prev", prev_month_data)
self.assertIn("first_day_third_prev", prev_month_data)
self.assertIn("last_day_third_prev", prev_month_data)
self.assertIn("sl_year", prev_month_data)
self.assertIn("sl_month", prev_month_data)
def test_update_config_files(self):
# Test update_config_files function
update_config_files(
self.temp_dir.name, "date", self.additional_content)
@patch("fetch.secretmanager.SecretManagerServiceClient")
def test_get_secret_success(self, mock_secretmanager):
secret_data = {
"api_url": "https://example.com/api",
"api_key": "my_secret_api_key"
}
mock_response = MagicMock()
mock_response.payload.data.decode.return_value = json.dumps(secret_data)
mock_secretmanager.return_value.access_secret_version.return_value = (
mock_response)
secret_key = "projects/my-project/secrets/my-secret/versions/latest"
result = get_secret(secret_key)
self.assertEqual(result, secret_data)
@patch("fetch.secretmanager.SecretManagerServiceClient")
def test_get_secret_failure(self, mock_secretmanager):
mock_secretmanager.return_value.access_secret_version.side_effect = (
Exception("Error retrieving secret"))
secret_key = "projects/my-project/secrets/my-secret/versions/latest"
with self.assertRaises(Exception):
get_secret(secret_key)
if __name__ == "__main__":
unittest.main()
|
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
r"""Convert Surface level Era 5 Data to an unprocessed Zarr dataset.
Examples:
Check if there's any missing data:
```
python src/single-levels-to-zarr.py gs://gcp-public-data-arco-era5/co/single-level-reanalysis.zarr gs://$BUCKET/an-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--target-chunk '{"time": 1}' \
--setup_file ./setup.py \
--find-missing
```
Produce the output file locally:
```
python src/single-levels-to-zarr.py ~/single-level-reanalysis.zarr ~/an-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--target-chunk '{"time": 1}' \
--local-run \
--setup_file ./setup.py
```
Perform the conversion for the reanalysis dataset...
```
python src/single-levels-to-zarr.py gs://gcp-public-data-arco-era5/co/single-level-reanalysis.zarr gs://$BUCKET/an-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--target-chunk '{"time": 1}' \
--runner DataflowRunner \
--project $PROJECT \
--region $REGION \
--setup_file ./setup.py \
--disk_size_gb 50 \
--machine_type n2-highmem-2 \
--no_use_public_ips \
--network=$NETWORK \
--subnetwork=regions/$REGION/subnetworks/$SUBNET \
--job_name reanalysis-to-zarr
```
Perform the conversion for the forecast dataset...
```
python src/single-levels-to-zarr.py gs://gcp-public-data-arco-era5/co/single-level-forecast.zarr gs://$BUCKET/fc-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--chunks rad pcp_surface_cp pcp_surface_crr pcp_surface_csf pcp_surface_csfr pcp_surface_es pcp_surface_lsf \
pcp_surface_lsp pcp_surface_lspf pcp_surface_lsrr pcp_surface_lssfr pcp_surface_ptype pcp_surface_rsn \
pcp_surface_sd pcp_surface_sf pcp_surface_smlt pcp_surface_tp \
--target-chunk '{"time": 1, "step": 1}' \
--runner DataflowRunner \
--project $PROJECT \
--region $REGION \
--setup_file ./setup.py \
--disk_size_gb 50 \
--machine_type n2-highmem-2 \
--no_use_public_ips \
--network=$NETWORK \
--subnetwork=regions/$REGION/subnetworks/$SUBNET \
--job_name forecasts-to-zarr
```
Perform the conversion for the surface dataset...
```
python src/single-levels-to-zarr.py gs://gcp-public-data-arco-era5/co/single-level-surface.zarr gs://$BUCKET/sfc-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--chunks lnsp zs \
--target-chunk '{"time": 1}' \
--runner DataflowRunner \
--project $PROJECT \
--region $REGION \
--setup_file ./setup.py \
--disk_size_gb 50 \
--machine_type n2-highmem-2 \
--no_use_public_ips \
--network=$NETWORK \
--experiment=use_runner_v2 \
--sdk_container_image=gcr.io/$PROJECT/miniconda3-beam:0.0.3.git \
--subnetwork=regions/$REGION/subnetworks/$SUBNET \
--job_name surface-to-zarr
```
"""
import datetime
import logging
import pandas as pd
from arco_era5 import run, parse_args
if __name__ == "__main__":
logging.getLogger('pangeo_forge_recipes').setLevel(logging.DEBUG)
logging.getLogger().setLevel(logging.INFO)
def make_path(time: datetime.datetime, chunk: str) -> str:
"""Make path to Era5 data from timestamp and variable."""
# Handle chunks that have been manually split into one-variable files.
if '_' in chunk:
chunk_, level, var = chunk.split('_')
return (
f"gs://gcp-public-data-arco-era5/raw/ERA5GRIB/HRES/Month/"
f"{time.year:04d}/{time.year:04d}{time.month:02d}_hres_{chunk_}.grb2_{level}_{var}.grib"
)
return (
f"gs://gcp-public-data-arco-era5/raw/ERA5GRIB/HRES/Month/"
f"{time.year:04d}/{time.year:04d}{time.month:02d}_hres_{chunk}.grb2"
)
default_chunks = [
'cape', 'cisst', 'sfc', 'tcol',
# the 'soil' chunk split by variable
'soil_depthBelowLandLayer_istl1',
'soil_depthBelowLandLayer_istl2',
'soil_depthBelowLandLayer_istl3',
'soil_depthBelowLandLayer_istl4',
'soil_depthBelowLandLayer_stl1',
'soil_depthBelowLandLayer_stl2',
'soil_depthBelowLandLayer_stl3',
'soil_depthBelowLandLayer_stl4',
'soil_depthBelowLandLayer_swvl1',
'soil_depthBelowLandLayer_swvl2',
'soil_depthBelowLandLayer_swvl3',
'soil_depthBelowLandLayer_swvl4',
'soil_surface_tsn',
]
parsed_args, unknown_args = parse_args('Convert Era 5 Single Level data to Zarr', default_chunks)
date_range = [
ts.to_pydatetime()
for ts in pd.date_range(start=parsed_args.start,
end=parsed_args.end,
freq="MS").to_list()
]
run(make_path, date_range, parsed_args, unknown_args)
|
# pylint: disable=line-too-long
r"""Create a single Zarr dataset from ERA5 NetCDF files.
While this pipeline is intended as a one off on the full data, it should be
possible to make some simple edits to the pipeline to append data for
subsequent years by:
* In a new location (otherwise xarray beam will delete everything!)
* Override the template to take into account any new dates.
* Change "daily_date_iterator" to only iterate over the new data to append (
while keeping the original "start_date" so chunk indices are still computed
correctly).
* Move all the generated files into the previous location, overwriting when
necessary (e.g. template/static files).
Example usage:
$ python src/netcdf_to_zarr.py \
--output_path="gs://gcp-public-data-arco-era5/ar/$USER-1959-2022-full_37-1h-0p25deg-chunk-1.zarr-v2" \
--pressure_levels_group="full_37" \
--time_chunk_size=1 \
--start_date '1959-01-01' \
--end_date '2021-12-31' \
--runner DataflowRunner \
--project $PROJECT \
--region $REGION \
--temp_location "gs://$BUCKET/tmp/" \
--setup_file ./setup.py \
--disk_size_gb 500 \
--machine_type m1-ultramem-40 \
--no_use_public_ips \
--network=$NETWORK \
--subnetwork=regions/$REGION/subnetworks/$SUBNET \
--job_name $USER-ar-zarr-full \
--number_of_worker_harness_threads 20
"""
# TODO(alvarosg): Make this pipeline resumable in case of error in the middle
# of execution.
__author__ = 'Matthew Willson, Alvaro Sanchez, Peter Battaglia, Stephan Hoyer, Stephan Rasp'
import dask
import fsspec
import logging
import apache_beam as beam
import numpy as np
import pandas as pd
import typing as t
import xarray as xa
import xarray_beam as xb
from arco_era5 import (
GCP_DIRECTORY,
STATIC_VARIABLES,
SINGLE_LEVEL_VARIABLES,
MULTILEVEL_VARIABLES,
PRESSURE_LEVELS_GROUPS,
TIME_RESOLUTION_HOURS,
get_var_attrs_dict,
read_multilevel_vars,
read_single_level_vars,
read_static_vars,
daily_date_iterator,
align_coordinates,
parse_arguments
)
INPUT_PATH = GCP_DIRECTORY
_HOURS_PER_DAY = 24
# TODO(alvarosg): Add pressure level chunk size.
def _get_pressure_levels_arg(pressure_levels_group: str):
return PRESSURE_LEVELS_GROUPS[pressure_levels_group]
def make_template(data_path: str, start_date: str, end_date: str, time_chunk_size: int,
pressure_levels_group: str) -> t.Tuple[xa.Dataset, t.Dict[str, int]]:
"""A lazy template with same dims/coords/vars as our expected results."""
# Get the variable attributes.
var_attrs_dict = get_var_attrs_dict(root_path=data_path)
# Get some sample multi-level data to get coordinates, only for one var,
# so it downloads quickly.
logging.info("Downloading one variable of sample data for template.")
first_year, first_month, first_day = next(iter(
daily_date_iterator(start_date, end_date)))
sample_multilevel_vars = align_coordinates(
read_multilevel_vars(
# Date is irrelevant.
first_year,
first_month,
first_day,
root_path=data_path,
variables=MULTILEVEL_VARIABLES[:1],
pressure_levels=_get_pressure_levels_arg(pressure_levels_group)))
logging.info("Finished downloading.")
lat_size = sample_multilevel_vars.sizes["latitude"]
lon_size = sample_multilevel_vars.sizes["longitude"]
level_size = sample_multilevel_vars.sizes["level"]
assert level_size == len(
_get_pressure_levels_arg(pressure_levels_group)
), "Mismatched level sizes"
# Take the coordinates from the richer, multi-level dataset.
coords = dict(sample_multilevel_vars.coords)
coords["time"] = pd.date_range(
pd.Timestamp(start_date),
pd.Timestamp(end_date),
freq=pd.DateOffset(hours=TIME_RESOLUTION_HOURS),
).values
time_size = len(coords["time"])
template_dataset = {}
for name in STATIC_VARIABLES:
template_dataset[name] = xa.Variable(
dims=("latitude", "longitude"),
data=dask.array.zeros(
shape=(lat_size, lon_size),
dtype=np.float32),
attrs=var_attrs_dict[name])
for name in SINGLE_LEVEL_VARIABLES:
template_dataset[name] = xa.Variable(
dims=("time", "latitude", "longitude"),
data=dask.array.zeros(
shape=(time_size, lat_size, lon_size),
chunks=-1, # Will give chunk info directly to `ChunksToZarr``.
dtype=np.float32),
attrs=var_attrs_dict[name])
for name in MULTILEVEL_VARIABLES:
template_dataset[name] = xa.Variable(
dims=("time", "level", "latitude", "longitude"),
data=dask.array.zeros(
shape=(time_size, level_size, lat_size, lon_size),
chunks=-1, # Will give chunk info directly to `ChunksToZarr``.
dtype=np.float32),
attrs=var_attrs_dict[name])
chunk_sizes = {"time": time_chunk_size}
return xa.Dataset(template_dataset, coords=coords), chunk_sizes
class LoadTemporalDataForDateDoFn(beam.DoFn):
def __init__(self, data_path, start_date, pressure_levels_group):
self.data_path = data_path
self.start_date = start_date
self.pressure_levels_group = pressure_levels_group
def process(self, args):
"""Loads temporal data for a day, with an xarray_beam key for it.."""
year, month, day = args
logging.info("Loading NetCDF files for %d-%d-%d", year, month, day)
try:
single_level_vars = read_single_level_vars(
year,
month,
day,
variables=SINGLE_LEVEL_VARIABLES,
root_path=self.data_path)
multilevel_vars = read_multilevel_vars(
year,
month,
day,
variables=MULTILEVEL_VARIABLES,
pressure_levels=_get_pressure_levels_arg(self.pressure_levels_group),
root_path=self.data_path)
except BaseException as e:
# Make sure we print the date as part of the error for easier debugging
# if something goes wrong. Note "from e" will also raise the details of the
# original exception.
raise Exception(f"Error loading {year}-{month}-{day}") from e
# It is crucial to actually "load" as otherwise we get a pickle error.
single_level_vars = single_level_vars.load()
multilevel_vars = multilevel_vars.load()
dataset = xa.merge([single_level_vars, multilevel_vars])
dataset = align_coordinates(dataset)
offsets = {"latitude": 0, "longitude": 0, "level": 0,
"time": offset_along_time_axis(self.start_date, year, month, day)}
key = xb.Key(offsets, vars=set(dataset.data_vars.keys()))
logging.info("Finished loading NetCDF files for %s-%s-%s", year, month, day)
yield key, dataset
dataset.close()
def offset_along_time_axis(start_date: str, year: int, month: int, day: int) -> int:
"""Offset in indices along the time axis, relative to start of the dataset."""
# Note the length of years can vary due to leap years, so the chunk lengths
# will not always be the same, and we need to do a proper date calculation
# not just multiply by 365*24.
time_delta = pd.Timestamp(
year=year, month=month, day=day) - pd.Timestamp(start_date)
return time_delta.days * _HOURS_PER_DAY // TIME_RESOLUTION_HOURS
def load_static_data(args, data_path: str) -> t.Tuple[xb.Key, xa.Dataset]:
"""Loads all static data, with an xarray_beam key for it.."""
logging.info("Loading static data")
dataset = read_static_vars(
variables=STATIC_VARIABLES, root_path=data_path)
logging.info("static data loaded.")
# It is crucial to actually "load" as otherwise we get a pickle error.
dataset = dataset.load()
# Technically the static data has a time coordinate, but we don't need it.
dataset = dataset.squeeze("time").drop("time")
dataset = align_coordinates(dataset)
offsets = {"latitude": 0, "longitude": 0}
key = xb.Key(offsets, vars=set(dataset.data_vars.keys()))
logging.info("Finished loading static data")
return key, dataset
def define_pipeline(
root: beam.Pipeline,
input_path: str,
output_path: str,
time_chunk_size: int,
start_date: str,
end_date: str,
pressure_levels_group: str
) -> t.Tuple[beam.Pipeline, beam.Pipeline]:
"""Defines a beam pipeline to convert the ERA5 NetCDF files to zarr."""
template, chunk_sizes = make_template(
input_path, start_date, end_date, time_chunk_size, pressure_levels_group)
# We will create a single `chunks_to_zarr` object, but connect it at the end
# of the two pipelines separately. This causes the full transformation to be
# fused into a single worker operation, which writes chunks directly to final
# location (So long as we provide a template and chose a chunk size that
# avoids the need for `xb.ConsolidateChunks`).
# This works much faster than:
# return ((temporal_variables_chunks, static_variables_chunks)
# | beam.Flatten()
# | chunks_to_zarr)
# which persists all data in an intermeddiate location.
chunks_to_zarr = xb.ChunksToZarr(
output_path,
# `xb.make_template` should not be necessary as `template`` is already
# a single chunk dask array of zeros, which is what `xb.make_template`
# converts it to.
template=xb.make_template(template),
zarr_chunks=chunk_sizes)
load_temporal_data_for_date_do_fn = LoadTemporalDataForDateDoFn(
data_path=input_path,
start_date=start_date,
pressure_levels_group=pressure_levels_group
)
logging.info("Setting up temporal variables.")
temporal_variables_chunks = (
root
| "DayIterator" >> beam.Create(daily_date_iterator(start_date, end_date))
| "TemporalDataForDay" >> beam.ParDo(load_temporal_data_for_date_do_fn)
| xb.SplitChunks(chunk_sizes)
# We can skip the consolidation if we are using a `time_chunk_size` that
# evenly divides a day worth of data.
# | xb.ConsolidateChunks(chunk_sizes)
| "ChunksToZarrTemporal" >> chunks_to_zarr
)
logging.info("Setting up static variables.")
static_variables_chunks = (
root
# This is a single element with no parameters.
| "DummySingleElement" >> beam.Create(range(1))
| "StaticVariableFromNetCDFFile" >> beam.Map(load_static_data,
data_path=input_path)
| "ChunksToZarrStatic" >> chunks_to_zarr
)
logging.info("Finished defining pipeline.")
return (temporal_variables_chunks, static_variables_chunks)
def main():
logging.getLogger().setLevel(logging.INFO)
fs = fsspec.filesystem('gcs')
known_args, pipeline_args = parse_arguments(
"Create a Zarr dataset from NetCDF files."
)
pipeline_args.extend(['--save_main_session', 'True'])
if fs.exists(known_args.output_path):
raise ValueError(f"{known_args.output_path} already exists")
num_steps_per_day = _HOURS_PER_DAY // TIME_RESOLUTION_HOURS
if num_steps_per_day % known_args.time_chunk_size != 0:
raise ValueError(
f"time_chunk_size {known_args.time_chunk_size} must evenly divide {num_steps_per_day}"
)
with beam.Pipeline(argv=pipeline_args) as root:
define_pipeline(
root,
input_path=INPUT_PATH,
output_path=known_args.output_path,
start_date=known_args.start_date,
end_date=known_args.end_date,
time_chunk_size=known_args.time_chunk_size,
pressure_levels_group=known_args.pressure_levels_group
)
if __name__ == "__main__":
main()
|
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
r"""Convert Model level Era 5 Data to an unprocessed Zarr dataset.
Examples:
Check if there's any missing data:
```
python src/model-levels-to-zarr.py gs://gcp-public-data-arco-era5/co/model-level-all.zarr gs://$BUCKET/ml-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--chunks o3q qrqs dve tw \
--target-chunk '{"time": 1, "hybrid": 1}' \
--setup_file ./setup.py \
--find-missing
```
Produce the output file locally:
```
python src/model-levels-to-zarr.py ~/model-level-all.zarr ~/ml-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--chunks o3q qrqs dve tw \
--target-chunk '{"time": 1, "hybrid": 1}' \
--local-run \
--setup_file ./setup.py
```
Perform the conversion for the moisture dataset...
```
python src/model-levels-to-zarr.py gs://gcp-public-data-arco-era5/co/model-level-moisture.zarr gs://$BUCKET/ml-moist-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--chunks o3q qrqs \
--target-chunk '{"time": 1, "hybrid": 1}' \
--runner DataflowRunner \
--project $PROJECT \
--region $REGION \
--setup_file ./setup.py \
--disk_size_gb 3600 \
--machine_type m1-ultramem-40 \
--no_use_public_ips \
--network=$NETWORK \
--subnetwork=regions/$REGION/subnetworks/$SUBNET \
--job_name model-level-moisture-to-zarr
```
Perform the conversion for the wind dataset...
```
python src/model-levels-to-zarr.py gs://gcp-public-data-arco-era5/co/model-level-wind.zarr gs://$BUCKET/ml-wind-cache/ \
--start 1979-01-01 \
--end 2021-08-31 \
--chunks dve tw \
--target-chunk '{"time": 1, "hybrid": 1}' \
--runner DataflowRunner \
--project $PROJECT \
--region $REGION \
--setup_file ./setup.py \
--disk_size_gb 3600 \
--machine_type m1-ultramem-40 \
--no_use_public_ips \
--network=$NETWORK \
--subnetwork=regions/$REGION/subnetworks/$SUBNET \
--job_name model-level-wind-to-zarr
```
"""
import datetime
import logging
import pandas as pd
from arco_era5 import run, parse_args
if __name__ == "__main__":
logging.getLogger('pangeo_forge_recipes').setLevel(logging.DEBUG)
logging.getLogger().setLevel(logging.INFO)
def make_path(time: datetime.datetime, chunk: str) -> str:
"""Make path to Era5 data from timestamp and variable."""
# Handle chunks that have been manually split into one-variable files.
if '_' in chunk:
chunk_, level, var = chunk.split('_')
return (
f"gs://gcp-public-data-arco-era5/raw/ERA5GRIB/HRES/Daily/"
f"{time.year:04d}/{time.year:04d}{time.month:02d}{time.day:02d}_hres_{chunk_}.grb2_{level}_{var}.grib"
)
return (
f"gs://gcp-public-data-arco-era5/raw/ERA5GRIB/HRES/Daily/"
f"{time.year:04d}/{time.year:04d}{time.month:02d}{time.day:02d}_hres_{chunk}.grb2"
)
default_chunks = ['dve', 'tw']
parsed_args, unknown_args = parse_args('Convert Era 5 Model Level data to Zarr', default_chunks)
date_range = [
ts.to_pydatetime()
for ts in pd.date_range(start=parsed_args.start,
end=parsed_args.end,
freq="D").to_list()
]
run(make_path, date_range, parsed_args, unknown_args)
|
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from .source_data import GCP_DIRECTORY,STATIC_VARIABLES,SINGLE_LEVEL_VARIABLES,MULTILEVEL_VARIABLES,PRESSURE_LEVELS_GROUPS, TIME_RESOLUTION_HOURS
from .source_data import get_var_attrs_dict, read_multilevel_vars, read_static_vars, read_single_level_vars, daily_date_iterator, align_coordinates, parse_arguments
from .pangeo import run, parse_args
|
"""Information and reading utils for the ERA 5 dataset."""
__author__ = 'Matthew Willson, Alvaro Sanchez, Peter Battaglia, Stephan Hoyer, Stephan Rasp'
import argparse
import fsspec
import immutabledict
import pathlib
import xarray
import numpy as np
import pandas as pd
import typing as t
import xarray as xr
TIME_RESOLUTION_HOURS = 1
GCP_DIRECTORY = "gs://gcp-public-data-arco-era5/raw"
STATIC_SUBDIR_TEMPLATE = "date-variable-static/2021/12/31/{variable}/static.nc"
SINGLE_LEVEL_SUBDIR_TEMPLATE = (
"date-variable-single_level/{year}/{month:02d}/"
"{day:02d}/{variable}/surface.nc")
MULTILEVEL_SUBDIR_TEMPLATE = (
"date-variable-pressure_level/{year}/{month:02d}/"
"{day:02d}/{variable}/{pressure_level}.nc")
STATIC_VARIABLES = (
"type_of_low_vegetation",
"type_of_high_vegetation",
"standard_deviation_of_orography",
"standard_deviation_of_filtered_subgrid_orography",
"soil_type",
"slope_of_sub_gridscale_orography",
"low_vegetation_cover",
"land_sea_mask",
"lake_depth",
"lake_cover",
"high_vegetation_cover",
"geopotential_at_surface",
"anisotropy_of_sub_gridscale_orography",
"angle_of_sub_gridscale_orography",
)
# TODO(alvarosg): Add more variables.
SINGLE_LEVEL_VARIABLES = (
"total_precipitation",
"total_column_water_vapour",
"total_cloud_cover",
"toa_incident_solar_radiation",
"surface_pressure",
"sea_surface_temperature",
"sea_ice_cover",
"mean_sea_level_pressure",
"2m_temperature",
"10m_v_component_of_wind",
"10m_u_component_of_wind",
)
MULTILEVEL_VARIABLES = (
"geopotential",
"specific_humidity",
"temperature",
"u_component_of_wind",
"v_component_of_wind",
"vertical_velocity",
)
# Variables that correspond to an integration over a `TIME_RESOLUTION_HOURS`
# interval, rather than an instantaneous sample in time.
# As per:
# https://confluence.ecmwf.int/pages/viewpage.action?pageId=197702790
# "ERA5 reanalysis (hourly data): accumulations are over the hour
# (the accumulation/processing "period) ending at the validity date/time"
# TODO(alvarosg): Verify somehow that it is true that these variables are indeed
# integrated for 1 hour, and not longer, because it is a bit suspicious that
# we don't have values for these variables until 1959-01-01 07:00:00, while
# for all other variables we have values since 1959-01-01 00:00:00, which may
# indicate at 6-8h accumulation.
CUMULATIVE_VARIABLES = ("total_precipitation",
"toa_incident_solar_radiation")
PRESSURE_LEVELS_GROUPS = immutabledict.immutabledict({
"weatherbench_13":
(50, 100, 150, 200, 250, 300, 400, 500, 600, 700, 850, 925, 1000),
"full_37": (1, 2, 3, 5, 7, 10, 20, 30, 50, 70, 100, 125, 150, 175, 200, 225,
250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 775, 800,
825, 850, 875, 900, 925, 950, 975, 1000)
})
# ERA5 uses "geopotential" for file names for both the static "geopotential"
# feature at surface, and the dynamic multilevel "geopotential". To avoid this
# clash, we will always rename the static one to "geopotential_at_surface".
_VARIABLE_TO_ERA5_FILE_NAME = {
"geopotential_at_surface": "geopotential"
}
def _read_nc_dataset(gpath_file):
"""Read the .nc dataset from disk."""
path = str(gpath_file).replace('gs:/', 'gs://')
with fsspec.open(path, mode="rb") as fid:
dataset = xarray.open_dataset(fid, engine="scipy", cache=False)
# All dataset have a single data array in them, so we just return the array.
assert len(dataset) == 1
dataarray = next(iter(dataset.values()))
if "expver" in dataarray.coords:
# Recent ERA5 downloads (within 2-3 months old) can include data from ERA5T,
# which is the temporary release of ERA5, which has not been validated.
# For such recent data, all instantaneous variables are from ERA5T, while
# accumulated variables can be a mix of ERA5 and ERA5T, because the earliest
# times of the accumulation window spans back from the range covered by
# ERA5T into the range covered by ERA5.
# Such NetCDF files indicate which ERA5 vs ERA5T with the `expver` axis,
# where `expver=1` means ERA5 and `expver=5` means ERA5T. For ERA5 times,
# NaNs are present in the `expver=5` slice, and for ERA5T times, NaNs are
# present in the `expver=1` slice.
# We combine and remove the `expver` axes using the below command.
# See: https://confluence.ecmwf.int/pages/viewpage.action?pageId=173385064
# and: https://confluence.ecmwf.int/display/CKB/ERA5%3A+data+documentation#ERA5:datadocumentation-Dataupdatefrequency # pylint: disable=line-too-long
# for further details.
all_dims_except_time = tuple(set(dataarray.dims) - {"time"})
# Should have only trailing nans.
a = dataarray.sel(expver=1).isnull().any(dim=all_dims_except_time)
# Should having only leading nans.
b = dataarray.sel(expver=5).isnull().any(dim=all_dims_except_time)
disjoint_nans = bool(next(iter((a ^ b).all().data_vars.values())))
assert disjoint_nans, "The nans are not disjoint in expver=1 vs 5"
dataarray = dataarray.sel(expver=1).combine_first(dataarray.sel(expver=5))
return dataarray
def read_static_vars(variables=STATIC_VARIABLES, root_path=GCP_DIRECTORY):
"""xarray.Dataset with static variables for single level data from nc files."""
root_path = pathlib.Path(root_path)
output = {}
for variable in variables:
if variable in _VARIABLE_TO_ERA5_FILE_NAME:
era5_variable = _VARIABLE_TO_ERA5_FILE_NAME[variable]
else:
era5_variable = variable
relative_path = STATIC_SUBDIR_TEMPLATE.format(variable=era5_variable)
output[variable] = _read_nc_dataset(root_path / relative_path)
return xarray.Dataset(output)
def read_single_level_vars(year, month, day, variables=SINGLE_LEVEL_VARIABLES,
root_path=GCP_DIRECTORY):
"""xarray.Dataset with variables for singel level data from nc files."""
root_path = pathlib.Path(root_path)
output = {}
for variable in variables:
relative_path = SINGLE_LEVEL_SUBDIR_TEMPLATE.format(
year=year, month=month, day=day, variable=variable)
output[variable] = _read_nc_dataset(root_path / relative_path)
return xarray.Dataset(output)
def read_multilevel_vars(year,
month,
day,
variables=MULTILEVEL_VARIABLES,
pressure_levels=PRESSURE_LEVELS_GROUPS["full_37"],
root_path=GCP_DIRECTORY):
"""xarray.Dataset with variables for all levels from nc files."""
root_path = pathlib.Path(root_path)
output = {}
for variable in variables:
pressure_data = []
for pressure_level in pressure_levels:
relative_path = MULTILEVEL_SUBDIR_TEMPLATE.format(
year=year, month=month, day=day, variable=variable,
pressure_level=pressure_level)
single_level_data_array = _read_nc_dataset(root_path / relative_path)
single_level_data_array.coords["level"] = pressure_level
pressure_data.append(
single_level_data_array.expand_dims(dim="level", axis=1))
output[variable] = xarray.concat(pressure_data, dim="level")
return xarray.Dataset(output)
def get_var_attrs_dict(root_path=GCP_DIRECTORY):
"""Returns attributes for all variables."""
root_path = pathlib.Path(root_path)
# The variable attributes should be independent of the date chosen here
# so we just choose any date.
year = 2021
month = 1
day = 1
pressure_level = PRESSURE_LEVELS_GROUPS["full_37"][-1]
# TODO(alvarosg): Store a version of this somewhere so we don't actually
# have to download the data files to get this into.
var_attrs_dict = {}
for variables, template, rename_dict in [
(STATIC_VARIABLES, STATIC_SUBDIR_TEMPLATE, _VARIABLE_TO_ERA5_FILE_NAME),
(SINGLE_LEVEL_VARIABLES, SINGLE_LEVEL_SUBDIR_TEMPLATE, {}),
(MULTILEVEL_VARIABLES, MULTILEVEL_SUBDIR_TEMPLATE, {}),
]:
for variable in variables:
if variable in rename_dict:
era5_variable = rename_dict[variable]
else:
era5_variable = variable
relative_path = template.format(
year=year, month=month, day=day, variable=era5_variable,
pressure_level=pressure_level)
data_array = _read_nc_dataset(root_path / relative_path)
data_array.attrs["short_name"] = data_array.name
var_attrs_dict[variable] = data_array.attrs
return var_attrs_dict
def daily_date_iterator(start_date: str, end_date: str
) -> t.Iterable[t.Tuple[int, int, int]]:
"""Iterates all (year, month, day) tuples between start_date and end_date."""
date_range = pd.date_range(start=start_date, end=end_date, inclusive='left')
for date in date_range:
yield date.year, date.month, date.day
def align_coordinates(dataset: xr.Dataset) -> xr.Dataset:
"""Align coordinates of per-variable datasets prior to consolidation."""
# It's possible to have coordinate metadata for coordinates which aren't
# actually used as dimensions of any variables (called 'non-index'
# coordinates), and some of the source NetCDF files use these, e.g. a scalar
# 'height' coordinate (= 2.0) in the NetCDF files for the 2-meter temperature
# variable tas. We remove these, for simplicity and since once the variables
# are combined in a single zarr dataset it won't be clear what these
# additional coordinates are referring to.
dataset = dataset.reset_coords(drop=True)
# Downcast lat and lon coordinates to float32. This is because there are
# small rounding-error (~1e-14 relative error) discrepancies between the
# float64 latitude coordinates across different source NetCDF files, and
# xarray_beam complains about this. After downcasting to float32 the
# differences go away, and the extra float64 precision isn't important to us.
# (Ideally you'd be able to specify a tolerance for the comparison, but this
# works for now.)
dataset = dataset.assign_coords(
latitude=dataset["latitude"].astype(np.float32),
longitude=dataset["longitude"].astype(np.float32))
return dataset
def parse_arguments(desc: str) -> t.Tuple[argparse.Namespace, t.List[str]]:
parser = argparse.ArgumentParser(description=desc)
parser.add_argument("--output_path", type=str, required=True,
help="Path to the destination Zarr archive.")
parser.add_argument('-s', "--start_date", default='2020-01-01',
help='Start date, iso format string.')
parser.add_argument('-e', "--end_date", default='2020-01-02',
help='End date, iso format string.')
parser.add_argument("--temp_location", type=str, required=True,
help="A temp location where this data is stored temporarily.")
parser.add_argument('--find-missing', action='store_true', default=False,
help='Print all paths to missing input data.') # implementation pending
parser.add_argument("--pressure_levels_group", type=str, default="weatherbench_13",
help="Group label for the set of pressure levels to use.")
parser.add_argument("--time_chunk_size", type=int, required=True,
help="Number of 1-hourly timesteps to include in a \
single chunk. Must evenly divide 24.")
return parser.parse_known_args()
|
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Common Pangeo-Forge Recipe definition for converting ERA5 datasets to Zarr."""
import argparse
import datetime
import itertools
import json
import os
import typing as t
from urllib import parse
import apache_beam as beam
import gcsfs
from fsspec.implementations.local import LocalFileSystem
from pangeo_forge_recipes.patterns import ConcatDim, FilePattern, MergeDim
from pangeo_forge_recipes.recipes import XarrayZarrRecipe
from pangeo_forge_recipes.storage import FSSpecTarget, MetadataTarget, StorageConfig
PROGRESS = itertools.cycle(''.join([c * 10 for c in '|/–-\\']))
def normalize_path(path: str) -> str:
parsed_output = parse.urlparse(path)
return f'{parsed_output.netloc}{parsed_output.path}'
def check_url(url):
parsed_gcs_path = parse.urlparse(url)
return parsed_gcs_path.scheme == 'gs'
def run(make_path: t.Callable[..., str], date_range: t.List[datetime.datetime],
parsed_args: argparse.Namespace, other_args: t.List[str]):
"""Perform the Zarr conversion pipeline with Pangeo Forge Recipes."""
if parsed_args.local_run and ( check_url(parsed_args.output) or check_url(parsed_args.temp) ):
raise ValueError("'output' and 'temp' path must be local path.")
date_dim = ConcatDim("time", date_range)
chunks_dim = MergeDim("chunk", parsed_args.chunks)
pattern = FilePattern(make_path, date_dim, chunks_dim, file_type='grib')
# remove 'indexpath' experimental feature; it breaks the pipeline
# see https://github.com/ecmwf/cfgrib#grib-index-file
xarray_kwargs = {
'engine': 'cfgrib',
'backend_kwargs': {
'indexpath': '',
'read_keys': [
'pv',
'latitudeOfFirstGridPointInDegrees',
'longitudeOfFirstGridPointInDegrees',
'latitudeOfLastGridPointInDegrees',
'longitudeOfLastGridPointInDegrees'
]
},
'cache': False,
'chunks': {'time': 4},
}
fs = gcsfs.GCSFileSystem(project=os.environ.get('PROJECT', 'ai-for-weather'))
if parsed_args.find_missing:
print('Finding missing data...')
data_is_missing = False
for _, path in pattern.items():
print(next(PROGRESS), end='\r')
if not fs.exists(path):
data_is_missing = True
print(path)
if data_is_missing:
print('Found missing data.')
else:
print('No missing data found.')
return
fs = fs if not parsed_args.local_run else LocalFileSystem()
output_path = normalize_path(parsed_args.output)
temp_path = normalize_path(parsed_args.temp)
storage_config = StorageConfig(
target=FSSpecTarget(fs, output_path),
metadata=MetadataTarget(fs, f'{temp_path}meta/')
)
recipe = XarrayZarrRecipe(pattern,
storage_config=storage_config,
target_chunks=parsed_args.target_chunk,
subset_inputs=parsed_args.subset_inputs,
copy_input_to_local_file=True,
cache_inputs=False,
lock_timeout=120, # seconds until lock times out.
consolidate_zarr=True,
xarray_open_kwargs=xarray_kwargs)
with beam.Pipeline(argv=other_args) as p:
p | recipe.to_beam()
def parse_args(desc: str, default_chunks: t.List[str]) -> t.Tuple[argparse.Namespace, t.List[str]]:
parser = argparse.ArgumentParser(description=desc)
parser.add_argument('output', type=str, help='Path to output Zarr in Cloud bucket.')
parser.add_argument('temp', type=str, help='Path to cloud bucket for temporary data cache.')
parser.add_argument('--find-missing', action='store_true', default=False,
help='Print all paths to missing input data.')
parser.add_argument('-s', '--start', default='2020-01-01', help='Start date, iso format string.')
parser.add_argument('-e', '--end', default='2020-02-01', help='End date, iso format string.')
parser.add_argument('-c', '--chunks', metavar='chunks', nargs='+',
default=default_chunks,
help='Chunks of variables to merge together.')
parser.add_argument('-t', '--target-chunk', type=json.loads, default='{"time": 1}',
help='A JSON string; Divide target chunks of variables at output level.')
parser.add_argument('--subset-inputs', type=json.loads, default='{"time": 4}',
help='A JSON string; when reading a chunk from disk, divide them into smaller chunks across '
'each dimension. Think of this as the inverse of a chunk size (e.g. the total number of '
'sub chunks). Default: `{"time": 4}`')
parser.add_argument('-l', '--local-run', action='store_true',
help='Argument to produce the output file locally.'
'Note: "output" and "temp" must be local path.')
return parser.parse_known_args()
|
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
raise NotImplementedError('coming soon!')
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Build the Existing Tasks Split (based on Notebooks on Github).
Steps:
1. Download the notebooks.
2. Apply edits created by annotators.
3. Extract problems from each notebook.
"""
import hashlib
import html
import json
import pathlib
import re
import tempfile
from typing import Any, Dict, List, Optional, Text, Tuple
from absl import app
import diff_match_patch as dmp_module
import kaggle
import nbconvert
import nbformat
import requests
import tqdm
from arcade_nl2code.annotated_dataset import build_new_tasks_split # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import dataset as dataset_module # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import utils # pylint: disable=g-bad-import-order
LmExample = dataset_module.LmExample
Turn = dataset_module.Turn
Intent = dataset_module.Intent
Code = dataset_module.Code
Path = pathlib.Path
CELL_DELIMETER = '# In[ ]:'
SPLIT_DATASET_ROOT = Path('dataset/existing_tasks/')
METADATA_FILE_PATH = SPLIT_DATASET_ROOT / 'metadata.json'
KAGGLE_KERNEL_PATTERN = r'https://www\.kaggle\.com/code/(.*?)/(.*?)/notebook'
# Cache downloaded datasets to avoid duplicate requests.
DOWNLOAD_CACHE = {}
def canonicalize_code(code: Text) -> Text:
"""Filter ipython inline magic lines."""
lines = code.split('\n')
lines = [line for line in lines if not line.startswith('%')]
return '\n'.join(lines).strip()
def cells_to_python_code(cells: List[utils.Cell]) -> Text:
""""Convert code cells to python source ignoring markdown comments."""
py_code = ''
for _, cell in enumerate(cells):
if cell.source:
cell_text = (
canonicalize_code(cell.source.strip())
if cell.cell_type == 'code'
else nbconvert.filters.strings.comment_lines(cell.source).strip()
)
py_code += cell_text + '\n\n'
py_code = py_code.rstrip()
return py_code
def cells_to_text(cells: List[utils.Cell]) -> Text:
return utils.notebook_to_python(
cells,
cell_marker_style='nbconvert',
comment_markdown_cell=True,
)
def ensure_ending_newline(text: Text) -> Text:
if not text.endswith('\n'):
text += '\n'
return text
def cells_to_lm_prompt(cells: List[utils.Cell]) -> Text:
"""Convert cells to a textual prompt."""
linearized_source = cells_to_text(cells)
prompt = ensure_ending_newline(linearized_source) + f'\n\n{CELL_DELIMETER}\n'
return prompt
def extract_turn_examples(
nb: nbformat.NotebookNode,
turn_annotations: List[Dict[Text, Any]],
) -> List[LmExample]:
"""Extract an episode of multiple turns from an annotated notebook."""
turn_examples = []
context_cells = []
for turn_idx, turn_annotation in enumerate(turn_annotations):
intent_cell_idx = turn_annotation['intent_cell_idx']
code_cell_idx = turn_annotation['code_cell_idx']
assert code_cell_idx == intent_cell_idx + 1
last_cell_in_context_idx = -1
if turn_idx > 0:
last_cell_in_context_idx = turn_annotations[turn_idx - 1]['code_cell_idx']
delta_context_cells = nb.cells[
last_cell_in_context_idx + 1: intent_cell_idx]
context_cells.extend(delta_context_cells)
delta_code_context = cells_to_python_code(delta_context_cells)
code_context = cells_to_python_code(context_cells)
intent_cell = nb.cells[intent_cell_idx]
lm_prompt = cells_to_lm_prompt(context_cells + [intent_cell])
code_cell = nb.cells[code_cell_idx]
intent = Intent(
value=intent_cell.source,
is_cell_intent=True,
cell_idx=intent_cell_idx,
line_span=(0, len(intent_cell.source.split('\n'))),
not_sure=turn_annotation['not_sure'],
output_variables=turn_annotation['output_variables'],
)
code = Code(
value=code_cell.source,
cell_idx=code_cell_idx,
num_lines=len(intent_cell.source.split('\n')),
line_span=(0, len(intent_cell.source.split('\n'))),
)
turn_metadata = dict(
annotator_id=turn_annotation['annotator_id'],
utterance_without_output_spec=turn_annotation[
'utterance_without_output_spec']
)
turn = Turn(
intent=intent, code=code,
code_context=code_context, delta_code_context=delta_code_context,
metadata=turn_metadata,
)
examaple_metadata = dict(
context_cells=[
utils.Cell(cell_type=cell.cell_type, source=cell.source)
for cell in context_cells
],
delta_cell_num=len(delta_context_cells),
)
turn_example = LmExample(
input=lm_prompt, turn=turn,
metadata=examaple_metadata)
turn_examples.append(turn_example)
context_cells.append(intent_cell)
context_cells.append(code_cell)
return turn_examples
def apply_patch(text_before: Text, patch_text: Text) -> Text:
dmp = dmp_module.diff_match_patch()
patches = dmp.patch_fromText(patch_text)
text_after, metadata = dmp.patch_apply(patches, text_before)
assert all(metadata)
return text_after
def download_data(url: Text) -> Tuple[Text, bytes]:
"""Download dataset from Github or Kaggle."""
if url in DOWNLOAD_CACHE:
return DOWNLOAD_CACHE[url]
is_kaggle_dataset = url.startswith('https://www.kaggle.com/')
if is_kaggle_dataset:
with tempfile.TemporaryDirectory() as tmp_folder:
tmp_save_path = Path(tmp_folder)
build_new_tasks_split.download_kaggle_dataset_by_url(
url, tmp_save_path)
file_name = url.rpartition('?select=')[-1]
if not (tmp_save_path / file_name).exists():
raise FileNotFoundError(f'{file_name} not found at {url}.')
with (tmp_save_path / file_name).open('rb') as f:
result = (file_name, f.read())
else:
res = requests.request(url=url, method='get')
file_name = html.unescape(url.rpartition('/')[-1])
result = (file_name, res.content)
DOWNLOAD_CACHE[url] = result
return result
def download_notebook(
url: Text,
git_commit_sha: Optional[Text] = None,
) -> nbformat.NotebookNode:
"""Download a notebook from Github or Kaggle.com."""
m = re.fullmatch(KAGGLE_KERNEL_PATTERN, url)
if m:
api = kaggle.KaggleApi()
api.authenticate()
usename, kernel_name = m.group(1), m.group(2)
res = api.kernel_pull(usename, kernel_name)
data = res['blob']['source']
else:
url = url.replace(
'https://github.com/', 'https://raw.githubusercontent.com/').replace(
'/blob/master/', '/master/')
if git_commit_sha:
url = url.replace('/master/', f'/{git_commit_sha}/')
res = requests.request(url=url, method='get')
data = res.content
if res.status_code != 200:
raise RuntimeError(f'Error downloading {url}: {res.content}')
nb = nbformat.reads(data, as_version=4)
return nb
def build_dataset():
"""Build the existing tasks split of our dataset."""
split_metadata = json.load(METADATA_FILE_PATH.open())
dataset = []
for episode_metadata in tqdm.tqdm(split_metadata, desc='Building episodes.'):
provenance = episode_metadata['provenance']
notebook_url = provenance['url']
git_commit_sha = provenance['sha']
print(f'downloading {notebook_url}')
work_dir = episode_metadata['work_dir']
nb = download_notebook(notebook_url, git_commit_sha=git_commit_sha)
original_nb_source = utils.notebook_to_python(
nb,
cell_marker_style='vscode_custom',
comment_markdown_cell=False,
strip_cell_content=False,
)
# Update notebook to the edited one.
patch_text = episode_metadata['patch_text']
episode_nb_source = apply_patch(original_nb_source, patch_text)
episode_nb = utils.source_to_notebook(episode_nb_source)
# Extract turns.
turn_examples = extract_turn_examples(
episode_nb, episode_metadata['turns_metadata'])
# Create work dir.
target_work_dir = SPLIT_DATASET_ROOT / 'artifacts' / work_dir
target_work_dir.mkdir(parents=True, exist_ok=True)
# Download necessary data artifacts.
artifacts_metadata = provenance['artifacts']
for artifact_filename, artifact_entry in artifacts_metadata.items():
artifact_url = artifact_entry['url']
print(f'downloading {artifact_url}')
_, data = download_data(artifact_url)
md5_checksum = hashlib.md5(data).hexdigest()
if md5_checksum != artifact_entry['md5_checksum']:
raise ValueError(f'Dataset md5 checksum does not match: {artifact_url}')
(target_work_dir / artifact_filename).parent.mkdir(
parents=True, exist_ok=True)
with (target_work_dir / artifact_filename).open('wb') as f:
f.write(data)
episode = dict(
notebook_name=episode_metadata['notebook_name'],
annotator=episode_metadata['annotator'],
work_dir=work_dir,
provenance=provenance,
turns=turn_examples,
)
dataset.append(episode)
dataset_module.save_dataset(dataset, SPLIT_DATASET_ROOT / 'dataset.json')
def main(_) -> None:
build_dataset()
if __name__ == '__main__':
app.run(main)
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utility functions to extract and generate schema information."""
import ast
from concurrent import futures
import copy
import dataclasses
import enum
import multiprocessing
import os
import shutil
from typing import Any, Dict, List, Optional, Text, Type, TypedDict, Union, cast
import uuid
from absl import logging
import astor
from ipython_genutils import ipstruct
import numpy as np
import pandas as pd
from arcade_nl2code.annotated_dataset import dataset as dataset_module # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import utils # pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import execution # pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import variable_state_utils # pylint: disable=g-bad-import-order
LmExample = dataset_module.LmExample
Turn = dataset_module.Turn
Cell = ipstruct.Struct
CELL_OUTPUT_VARIABLE_NAME = '__output__'
class VariableType(enum.Enum):
"""Types of variable with annotatable schema information."""
PANDAS_DATAFRAME = 1
PANDAS_SERIES = 2
class VariableLocation(enum.Enum):
ORIGINAL = 1
INTERMEDIATE = 2
class VariableStateTextStyle(enum.Enum):
"""Format options of inlined variable states."""
# Use a synthetic line `df.columns = [...]`.
DF_COLUMNS = 1
# Use a natural language description of columns and their values.
HEADER_DESCRIPTION = 2
class VariableStateTextLocation(enum.Enum):
"""Options for where to insert linearized variable states."""
# Inline variable state as a comment before the variable creation line.
INLINE = 1
# Insert variable states as a separate notebook cell after
# the cell where the variable is created.
AFTER_VARIABLE_CELL = 2
# Insert all variable states as a single cell after where the last
# variable is created.
AFTER_LAST_VARIABLE_CELL = 3
@dataclasses.dataclass(frozen=True)
class SchemaRepresentationConfig:
"""Configures how schema information is inlined in code contexts."""
# Types of variables to annotate their schema or variable states.
variable_types: List[VariableType] = dataclasses.field(
default_factory=lambda: [VariableType.PANDAS_DATAFRAME])
# Location of those variables to annotate state information.
variable_location: VariableLocation = VariableLocation.ORIGINAL
# Variable state linearization style.
style: VariableStateTextStyle = VariableStateTextStyle.DF_COLUMNS
# Variable state linearization location.
location: VariableStateTextLocation = VariableStateTextLocation.AFTER_VARIABLE_CELL # pylint: disable=line-too-long
@classmethod
def from_string(cls, config_string: Text) -> 'SchemaRepresentationConfig':
"""Parse config from string."""
option_strings = config_string.split('.')
variable_types = [VariableType.PANDAS_DATAFRAME]
variable_location = VariableLocation.ORIGINAL
text_style = None
text_location = None
for option_string in option_strings:
if option_string == 'originating_dfs':
variable_location = VariableLocation.ORIGINAL
elif option_string == 'intermediate_dfs':
variable_location = VariableLocation.INTERMEDIATE
elif option_string == '+series':
variable_types.append(VariableType.PANDAS_SERIES)
elif option_string == 'header_description':
text_style = VariableStateTextStyle.HEADER_DESCRIPTION
elif option_string == 'df_columns':
text_style = VariableStateTextStyle.DF_COLUMNS
elif option_string == 'inline':
text_location = VariableStateTextLocation.INLINE
elif option_string == 'after_variable_cell':
text_location = VariableStateTextLocation.AFTER_VARIABLE_CELL
elif option_string == 'after_last_variable_cell':
text_location = VariableStateTextLocation.AFTER_LAST_VARIABLE_CELL
config = cls(variable_types, variable_location, text_style, text_location)
config.validate()
return config
def validate(self) -> bool:
"""Validate the configuration."""
if not self.style:
raise ValueError('Must specify one format style.')
return True
@dataclasses.dataclass
class Variable:
name: Text
line_num: int
value: Optional[Any] = None
schema_representation: Optional[Text] = None
class CellSchemaInfo(TypedDict):
"""Record of schema information for a notebook cell.
TODO(pcyin): Record variable states for more variable types.
"""
cell_idx: int
df_variables: List[Variable]
cell_schema_representation: Text
def copy_schema_info_list_without_variable_values(
schema_info_list: List[CellSchemaInfo]) -> List[CellSchemaInfo]:
"""Make a deep copy of a schema info list without `Variable.value`."""
new_schema_info_list = []
for schema_info in schema_info_list:
variables = []
for variable in schema_info['df_variables']:
variables.append(
Variable(
variable.name, variable.line_num,
value=None,
schema_representation=variable.schema_representation
)
)
new_schema_info = CellSchemaInfo(
cell_idx=schema_info['cell_idx'],
df_variables=variables,
cell_schema_representation=schema_info['cell_schema_representation'],
)
new_schema_info_list.append(new_schema_info)
return new_schema_info_list
DATAFRMAE_CREATION_FUNCTIONS = frozenset([
'read_csv', 'read_pickle', 'read_table', 'read_excel'])
class AstVisitor(ast.NodeVisitor):
"""Found pandas dataframe creation API calls.
Traverse an AST to extract metadata (name, line number) of variables defined
in assignment statements that are:
1. Initialized by functions listed in `DATAFRMAE_CREATION_FUNCTIONS`, or
2. Listed in `target_dataframes` in the constructor.
"""
def __init__(self, target_dataframes: Optional[List[Text]] = None):
self.created_dataframes: List[Variable] = []
self.target_dataframes = target_dataframes or []
def visit_Assign(self, node: ast.Assign): # pylint: disable=invalid-name
"""Extract meta information of created dataframes."""
new_variables = node.targets
new_variable = None
if len(new_variables) == 1:
new_variable_node = new_variables[0]
if isinstance(new_variable_node, ast.Name):
new_variable = new_variable_node.id
value_node = node.value
is_df_creation = self.has_df_creation_call(value_node)
if new_variable:
if is_df_creation or new_variable in self.target_dataframes:
self.created_dataframes.append(
Variable(name=new_variable, line_num=node.lineno))
def has_df_creation_call(self, node: ast.AST) -> bool:
"""Recursively check the RHS of an assignment statement."""
result = False
for _, value in ast.iter_fields(node):
if isinstance(value, str):
if value in DATAFRMAE_CREATION_FUNCTIONS:
return True
elif isinstance(value, list):
for item in value:
if isinstance(item, ast.AST):
result |= self.has_df_creation_call(item)
elif isinstance(item, str):
print(item)
if item in DATAFRMAE_CREATION_FUNCTIONS:
return True
elif isinstance(value, ast.AST):
result |= self.has_df_creation_call(value)
return result
def generate_df_header_description(
df: pd.DataFrame,
name: Text,
max_column_num: Optional[int] = None,
template: Text = '{column_name} ({value})',
strategy: Text = 'no_nan',
num_examples: int = 1,
max_cell_value_length: int = 80,
**kwargs
) -> Text:
"""Generate an NL description for a dataframe.
This is one of the many ways to represent schema information.
Args:
df: The dataframe variable.
name: Name of the dataframe.
max_column_num: Maximum number of columns to use (must be greater than one).
template: Template text.
strategy: How to select data content.
* no_nan: ignore NaN values.
* first_row: only use the first row.
num_examples: Number of rows to use in the description.
max_cell_value_length: Maximum length of stringified cell values. This makes
sure the natural language schema descriptions will not explode due to
some lengthy cell values.
**kwargs: Unused kwargs.
Returns:
A text description of the dataframe.
"""
del kwargs
# TODO(pcyin): Show N-unique values instead of just one.
max_column_num = max_column_num or len(df.columns)
column_names = list(df.columns[:max_column_num])
columns_desc_prefix = (
'Columns'
if len(df.columns) <= max_column_num
else f'First {max_column_num} columns')
def get_column_example_value(column_name, strategy):
if strategy == 'first_row':
return df.iloc[0][column_name]
elif strategy == 'no_nan':
try:
non_nan_df = df[df[column_name].notnull()][column_name]
except: # pylint: disable=bare-except
return 'NaN'
if len(non_nan_df) > 0: # pylint: disable=g-explicit-length-test
return non_nan_df.iloc[0]
else:
return 'NaN'
else:
raise ValueError(f'Unknown strategy to verbalize column: {strategy}')
def truncate_value(value):
value = str(value)
if max_cell_value_length > 0:
value = value[:max_cell_value_length]
return value
def get_data_type(dtype: np.dtype) -> Text:
if dtype == np.int_:
return 'int'
elif dtype == np.float_:
return 'float'
elif dtype == np.object_:
return 'string'
else:
return 'object'
if num_examples == 1:
header = f"""# {columns_desc_prefix} in {name} with example values:"""
column_and_values = [
template.format( # pylint: disable=g-complex-comprehension
column_name=column_name,
value=truncate_value(
get_column_example_value(column_name, strategy)),
dtype=get_data_type(getattr(df[column_name], 'dtype', None))
)
for column_name
in column_names
]
columns_representation = ', '.join(column_and_values)
columns_representation = (
header + '\n# ' + columns_representation)
description = columns_representation + '\n'
else:
header = (f"""# {columns_desc_prefix} in {name} with """
f"""up to {num_examples} example values:""")
columns_representation = ''
for column_name in column_names:
not_null_cells = df[df[column_name].notnull()][column_name]
top_k_values = not_null_cells.value_counts().index.tolist()[:num_examples]
if top_k_values:
top_k_values_string = ', '.join(
truncate_value(value)
for value in top_k_values
)
else:
top_k_values_string = 'NaN'
column_representation = template.format(
column_name=str(column_name),
value=top_k_values_string,
dtype=get_data_type(df[column_name].dtype)
)
column_representation = '# ' + column_representation + '\n'
columns_representation += column_representation
description = header + '\n' + columns_representation.rstrip() + '\n'
return description
def get_schema_summary_text_for_variable(
df: Union[pd.DataFrame, pd.Series],
name: Text,
schema_representation_config: SchemaRepresentationConfig,
max_column_num: int = 20,
verbalizer_kwargs: Optional[Dict[Text, Any]] = None,
) -> Text:
"""Get the schema summary text for a single pandas variable.
For now we only annotate variables of type pd.Series and pd.DataFrame.
Args:
df: A pandas variable.
name: Variable name, used in text summary.
schema_representation_config: Config for schema representation.
max_column_num: Maximum nunber of columns to be included in generated texts.
verbalizer_kwargs: Kwargs passed to the verbalizer that linearizes schema
representations to textual descriptions in prompts.
Returns:
A text summary of the input variable.
"""
schema_summary = None
verbalizer_kwargs = verbalizer_kwargs or dict()
schema_representation_config.validate()
if isinstance(df, pd.DataFrame):
if schema_representation_config.style == VariableStateTextStyle.DF_COLUMNS:
# Insert pseudo `df.columns = [col_name, ...]` statements as schema
# descriptions.
df_columns = [str(x) for x in df.columns]
columns_representation = ', '.join(
f"'{col_name}'" for col_name in df_columns[:max_column_num])
columns_representation = (
f'{name}.columns = [{columns_representation}]')
columns_comment = (
f'# Columns in {name}:'
if len(df.columns) <= max_column_num else
f'# First {max_column_num} columns in {name}:'
)
columns_representation = (
columns_comment + '\n' + columns_representation)
schema_summary = columns_representation + '\n'
elif schema_representation_config.style == VariableStateTextStyle.HEADER_DESCRIPTION: # pylint: disable=line-too-long
# Create a natural language description of columns and cell values
# in the dataframe.
schema_summary = generate_df_header_description(
df, name, max_column_num,
**verbalizer_kwargs
)
elif isinstance(df, pd.Series):
# TODO(pcyin): Include series values.
df = cast(pd.Series, df)
schema_summary = f'# {name} is a Series.'
sampled_df = df[:3]
if len(sampled_df) > 0: # pylint: disable=g-explicit-length-test
sampled_values = sampled_df.values.tolist()
value_desc = f'Sampled series values: {sampled_values}.'
if df.index is not None:
index_name = df.index.name
index_values = sampled_df.index.tolist()
index_desc = (
f'Index name: {index_name}, '
f'sampled index values: {index_values}.')
schema_summary += f' {index_desc} {value_desc}'
else:
schema_summary += f' {value_desc}'
else:
raise ValueError(f'Unsupported type: {type(df)}')
schema_summary = schema_summary.strip()
return schema_summary
def extract_schema_information_from_code_wrapper(
context_cells: List[Text],
schema_representation_config: SchemaRepresentationConfig,
work_dir: Optional[Text] = None,
max_column_num: int = 20,
verbalizer_kwargs: Optional[Dict[Text, Any]] = None,
target_dataframes: Optional[List[Text]] = None,
ignore_errors: bool = False
) -> List[CellSchemaInfo]:
"""A wrapper for extracting schema information in separate process."""
result = []
with multiprocessing.Pool(processes=1) as pool:
args = (
context_cells,
schema_representation_config,
work_dir,
max_column_num,
verbalizer_kwargs,
target_dataframes,
ignore_errors,
)
result = pool.starmap(extract_schema_information_from_code, [args])[0]
return result
def extract_schema_information_parallel(
dataset: List[Dict[Text, Any]],
**kwargs
) -> Dict[Text, futures.Future[List[CellSchemaInfo]]]:
"""Extract schema information in parallel."""
executor = futures.ProcessPoolExecutor(
max_workers=multiprocessing.cpu_count())
schema_info_fs = dict()
runtime_artifacts_root = kwargs.pop('runtime_artifacts_root')
for episode_idx, episode in enumerate(dataset):
notebook_name = episode['notebook_name']
turn_example: LmExample
for turn_idx, turn_example in enumerate(episode['turns']):
# Split concatenated cells in the original dataset to a list.
context_cells = utils.split_to_cells(turn_example.input)
work_dir = os.path.join(runtime_artifacts_root, episode['work_dir'])
f = executor.submit(
extract_schema_information_from_code_wrapper,
context_cells=context_cells,
work_dir=work_dir,
**kwargs,
)
schema_info_future_key = (
f'{notebook_name}_episode{episode_idx}_turn{turn_idx}')
schema_info_fs[schema_info_future_key] = f
return schema_info_fs
def get_created_or_modified_variable_names(
variables_dict_before: Optional[Dict[Text, Any]],
variables_dict_after: Dict[Text, Any],
target_variable_types: Optional[List[Type[Any]]] = None,
) -> List[Text]:
"""Get the variable names that are newly created or modified.
Args:
variables_dict_before: Dict of variable names and values before execution.
variables_dict_after: Dict of variable names and values after execution.
target_variable_types: Allow list of variable types for the output. By
default this function only returns pandas variables, including pd.Series
and pd.DataFrame.
Returns:
A list of new or modified variable names.
"""
target_variable_types = target_variable_types or [pd.DataFrame, pd.Series]
variables_dict_before = variables_dict_before or {}
delta_state = (
variable_state_utils.extract_delta_execution_state_from_exec_globals(
variables_dict_before, variables_dict_after
)
)
df_names = []
for var_name, var in delta_state.states.items():
if isinstance(var.value, tuple(target_variable_types)):
df_names.append(var_name)
return df_names
def assign_output_variable_name_to_last_stmt(source: Text) -> Text:
"""Assign output of the last expression to a variable."""
class _AstTransformer(ast.NodeTransformer): # pylint: disable=missing-class-docstring
def visit_Module(self, node: ast.Module) -> ast.Module: # pylint: disable=invalid-name, missing-function-docstring
new_body = []
for stmt_id, stmt in enumerate(node.body):
# Find the last statement.
if (
stmt_id == len(node.body) - 1 and
isinstance(stmt, ast.Expr) and
not isinstance(stmt, ast.Assign)
):
new_stmt = ast.Assign(
targets=(
[ast.Name(id=CELL_OUTPUT_VARIABLE_NAME, ctx=ast.Load())]
),
value=stmt.value,
ctx=ast.Load()
)
else:
new_stmt = stmt
new_body.append(new_stmt)
return ast.Module(body=new_body)
code_ast: ast.Module = ast.parse(source)
modified_ast = _AstTransformer().visit(code_ast)
modified_code = astor.to_source(modified_ast)
return modified_code
def post_process_source(source: Text) -> Text:
"""Post-process code for headless execution."""
source = source.rstrip()
# Remove plot rednering call to prevent from rendering figures
# to headless console.
if source.endswith('fig.show()'):
source = source[: source.rfind('\n')]
if 'iplot(' in source:
# Overload iplot.
ctx = """def iplot(*args, **kwargs): pass\n\n"""
source = ctx + source
return source
def extract_schema_information_from_code(
context_cells: List[Text],
schema_representation_config: SchemaRepresentationConfig,
work_dir: Optional[Text] = None,
max_column_num: int = 20,
# TODO(pcyin): Quote cell values as an optional flag in `verbalizer_kwargs`.
verbalizer_kwargs: Optional[Dict[Text, Any]] = None,
target_dataframes: Optional[List[Text]] = None,
ignore_errors: bool = False,
save_variables: bool = False
) -> List[CellSchemaInfo]:
"""Execute notebook cells and extract schema information of data frames.
This function progressively executes the list of code cells and extract schema
information from executed variable states.
Args:
context_cells: List of code cells in a notebook to execute and infer Schema
information.
schema_representation_config: Config of schema representation details.
work_dir: Working directory.
max_column_num: Truncate dataframe schema representation to this value.
verbalizer_kwargs: Kwargs to pass to the verbalizer function that converts
schema information to a text summary.
target_dataframes: List of pre-specified dataframes to annotate schema
information.
ignore_errors: Whether to ignore execution errors.
save_variables: Whether to save variable values in CellSchemaInfo. Turning
this on will increase memory usage.
Returns:
A list of dict. Each dict corresponses to a code cell with information of
dataframes (e.g., its value and a text summary) defined in that cell.
Raises:
RuntimeError: if encounters execution error.
"""
schema_representation_config.validate()
use_inline = (
schema_representation_config.location == VariableStateTextLocation.INLINE)
variable_location = schema_representation_config.variable_location
results = []
exec_globals = {}
tmp_work_dir = os.path.join('/tmp/', str(uuid.uuid4()))
assert not os.path.exists(tmp_work_dir)
if work_dir:
logging.debug('Copying artifacts from %s to %s', work_dir, tmp_work_dir)
shutil.copytree(work_dir, tmp_work_dir)
else:
os.makedirs(tmp_work_dir)
pwd = os.getcwd()
os.chdir(tmp_work_dir)
for cell_idx, cell_source in enumerate(context_cells):
is_markdown = all(
not line.strip() or line.strip().startswith('#')
for line in cell_source.split('\n'))
if not is_markdown:
cell_source = post_process_source(cell_source)
prev_exec_globals = None
# `assign_output_variable_name_to_last_stmt` will modify the original code
# so we do not do this if variable states are inlined.
if variable_location == VariableLocation.INTERMEDIATE and not use_inline:
prev_exec_globals = execution.copy_variable_dict(exec_globals)
cell_source = assign_output_variable_name_to_last_stmt(cell_source)
exec_state = execution.exec_wrapper(cell_source, exec_globals)
if exec_state.error:
if ignore_errors:
logging.warning(
'Error in executing code from work dir: %s: \n'
'Code:\n%s\n'
'Error Message:\n%s',
work_dir,
cell_source,
exec_state.error_text
)
return results
else:
raise RuntimeError(
f'Error when executing in cwd {tmp_work_dir}:\n' +
f'Code:\n{cell_source}\n' +
'Error: ' + exec_state.error_text)
if not use_inline and variable_location == VariableLocation.INTERMEDIATE:
# Case 1: When not inlining variable states and using intermediate
# annotation, collect candidate variables to annotate using the
# diff of execution states.
candidate_variable_names = get_created_or_modified_variable_names(
prev_exec_globals,
exec_state.exec_globals
)
# When cell output has been assigned to a variable, remove the
# placehodler variable that stores cell outputs.
if CELL_OUTPUT_VARIABLE_NAME in candidate_variable_names:
for var_name in candidate_variable_names:
if (
var_name != CELL_OUTPUT_VARIABLE_NAME and
variable_state_utils.is_variable_equal(
exec_state.exec_globals[var_name],
exec_state.exec_globals[CELL_OUTPUT_VARIABLE_NAME]
)
):
candidate_variable_names.remove(CELL_OUTPUT_VARIABLE_NAME)
break
candidate_dataframes = [
Variable(name=name, line_num=None)
for name
in candidate_variable_names
]
else:
# Case 2: When only annotate original df variables or inlining
# variable states, collect candidate variables using ASTVisitor,
# which assigns variable locations but has lower recall than using
# execution state diff.
# If only annotate original df variables regardless of inline options.
if variable_location == VariableLocation.ORIGINAL:
candidate_variable_names = target_dataframes or []
else:
# If inline variable states.
candidate_variable_names = get_created_or_modified_variable_names(
prev_exec_globals,
exec_state.exec_globals
)
ast_visitor = AstVisitor(target_dataframes=candidate_variable_names)
cell_ast = ast.parse(cell_source)
ast_visitor.visit(cell_ast)
candidate_dataframes = ast_visitor.created_dataframes
# Create natural language variable state description.
cell_dataframes = []
cell_schema_representation_text = ''
for df_entry in candidate_dataframes:
if df_entry.name in exec_state.exec_globals:
df = exec_state.exec_globals[df_entry.name]
target_variable_types = (pd.DataFrame,)
if VariableType.PANDAS_SERIES in schema_representation_config.variable_types: # pylint: disable=line-too-long
target_variable_types += (pd.Series,)
if isinstance(df, target_variable_types):
if save_variables:
df_entry.value = df
try:
df_schema_representation = get_schema_summary_text_for_variable(
df,
name=(
df_entry.name
if df_entry.name != CELL_OUTPUT_VARIABLE_NAME
else 'cell output'
),
max_column_num=max_column_num,
schema_representation_config=schema_representation_config,
verbalizer_kwargs=verbalizer_kwargs
)
except AttributeError as e:
# TODO(pcyin): Check this bug in recent pandas version.
if "'DataFrame' object has no attribute '_attrs'" in str(e):
continue
else:
raise e
df_entry.schema_representation = df_schema_representation
cell_schema_representation_text += df_schema_representation + '\n'
cell_dataframes.append(df_entry)
if cell_dataframes:
results.append(dict(
cell_idx=cell_idx,
df_variables=cell_dataframes,
cell_schema_representation=cell_schema_representation_text
))
exec_globals = exec_state.exec_globals
os.chdir(pwd)
return results
def get_schema_summary_text(
dataframe_schema_info: List[Dict[Text, Any]],
cutoff_cell_idx: Optional[int] = None,
separate_entries_with_newline: bool = False
) -> Text:
"""Get a single schema summary text for code cells up to a cutoff index.
This function uses exracted schema information from
`extract_schema_information_from_code` and linearize it to text.
Args:
dataframe_schema_info: Extracted schema information.
cutoff_cell_idx: Only include schemas for code that come before this
index (exclusive).
separate_entries_with_newline: Whether to separate schema texts of different
dataframes with new lines.
Returns:
A text summary of schemas.
"""
schema_summary_text = ''
num_dataframes = 0
for entry in dataframe_schema_info:
df_cell_idx = entry['cell_idx']
if cutoff_cell_idx is None or df_cell_idx < cutoff_cell_idx:
schema_summary_text += (
entry['cell_schema_representation'].rstrip() + '\n')
if separate_entries_with_newline:
schema_summary_text += '\n'
num_dataframes += 1
schema_summary_text = schema_summary_text.strip()
return schema_summary_text
def inline_schema_representation(
source: Text,
schema_info: CellSchemaInfo
) -> Text:
"""Inline variable state text as comment before the variable creation line."""
code_lines = source.split('\n')
df_variables = schema_info['df_variables']
modified_code_lines = []
df_variable: Variable
df_variables = sorted(df_variables, key=lambda x: x.line_num)
last_df_line_idx = 0
for df_variable in df_variables:
modified_code_lines.extend(
code_lines[last_df_line_idx:df_variable.line_num - 1])
if modified_code_lines:
last_line = modified_code_lines[-1]
if last_line.strip() and not last_line.lstrip().startswith('#'):
# Insert a line break.
modified_code_lines.append('')
modified_code_lines.append(df_variable.schema_representation)
last_df_line_idx = df_variable.line_num - 1
modified_code_lines.extend(code_lines[last_df_line_idx:])
modified_code = '\n'.join(modified_code_lines).strip()
return modified_code
def insert_schema_representations_to_cells(
cells: List[Text],
schema_info: List[CellSchemaInfo],
schema_representation_config: SchemaRepresentationConfig,
start_cell_idx: int = 0,
turn_example: Optional[LmExample] = None
) -> List[Text]:
"""Insert textual schema representations to notebook cells."""
cells = copy.deepcopy(cells)
if not schema_info and not schema_representation_config:
raise ValueError(
'Must provide schema_info and schema_representation_config')
if schema_representation_config.location == VariableStateTextLocation.INLINE:
modified_cells = []
for rel_cell_idx, cell in enumerate(cells):
abs_cell_idx = start_cell_idx + rel_cell_idx
cell_schema_info = [
x
for x in schema_info
if abs_cell_idx == x['cell_idx']
]
if cell_schema_info:
cell_schema_info = cell_schema_info[0]
modified_cell = inline_schema_representation(
cell, cell_schema_info)
else:
modified_cell = cell
modified_cells.append(modified_cell)
cells = modified_cells
elif schema_representation_config.location == VariableStateTextLocation.AFTER_VARIABLE_CELL: # pylint: disable=line-too-long
modified_cells = []
# Add original dfs created before start_cell_idx
cell_schema_info_before = [
x
for x in schema_info
if x['cell_idx'] < start_cell_idx
]
if cell_schema_info_before:
schema_summary_text = get_schema_summary_text(
schema_info,
cutoff_cell_idx=start_cell_idx
)
schema_summary_text = f"""
# Schema of Dataframes:
{schema_summary_text}
""".strip()
modified_cells.append(schema_summary_text)
for rel_cell_idx, cell in enumerate(cells):
abs_cell_idx = start_cell_idx + rel_cell_idx
cell_schema_info = [
x
for x in schema_info
if abs_cell_idx == x['cell_idx']
]
modified_cells.append(cell)
if cell_schema_info:
cell_schema_info = cell_schema_info[0]
schema_summary_text = f"""
# Schema of Dataframes:
{cell_schema_info['cell_schema_representation']}
""".strip()
modified_cells.append(schema_summary_text)
cells = modified_cells
elif schema_representation_config.location == VariableStateTextLocation.AFTER_LAST_VARIABLE_CELL: # pylint: disable=line-too-long
assert turn_example
schema_summary_text = get_schema_summary_text(
schema_info,
cutoff_cell_idx=turn_example.turn.code.cell_idx
)
schema_summary_text = f"""
# Schema of Dataframes:
{schema_summary_text}
""".strip()
last_df_creation_cell_idx = max(x['cell_idx'] for x in schema_info)
df_info_insert_loc = max(start_cell_idx, last_df_creation_cell_idx + 1)
df_info_insert_relative_idx = df_info_insert_loc - start_cell_idx
assert df_info_insert_relative_idx >= 0
cells.insert(
df_info_insert_relative_idx,
schema_summary_text
)
return cells
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for schema_utils."""
# pylint: disable=g-bad-import-order
import ast
from absl.testing import absltest
import pandas as pd
from arcade_nl2code.annotated_dataset import schema_utils
Variable = schema_utils.Variable
VariableType = schema_utils.VariableType
VariableLocation = schema_utils.VariableLocation
VariableStateTextLocation = schema_utils.VariableStateTextLocation
VariableStateTextStyle = schema_utils.VariableStateTextStyle
SchemaRepresentationConfig = schema_utils.SchemaRepresentationConfig
EXAMPLE_DF = pd.DataFrame(
[
['United States', '$19.485 trillion', '2.27%', '325,084,756'],
['China', '$12.238 trillion', '6.90%', '1,421,021,791'],
['Japan', '$5.065 trillion', '0.3%', '125,800,000']
],
columns=['State', 'GDP', 'Growth Rate', 'Population'],
)
CODE = """
import pandas as pd
df_1 = pd.read_csv('data.csv')
df_2 = pd.read_csv('data_2.csv')
result = df.loc[:5].sort_values()
another_df = pd.merge(df_1, df_2)
""".strip()
# TODO(pcyin): Test more util functions.
class SchemaUtilsTest(absltest.TestCase):
def test_ast_visitor_on_df_creation(self):
code_ast = ast.parse(CODE)
visitor = schema_utils.AstVisitor()
visitor.visit(code_ast)
expected = [
Variable(name='df_1', line_num=3),
Variable(name='df_2', line_num=5)
]
self.assertListEqual(visitor.created_dataframes, expected)
def test_ast_visitor_on_specified_dfs(self):
code_ast = ast.parse(CODE)
visitor = schema_utils.AstVisitor(
target_dataframes=['df_1', 'df_2', 'result', 'another_df'])
visitor.visit(code_ast)
expected = [
Variable(name='df_1', line_num=3),
Variable(name='df_2', line_num=5),
Variable(name='result', line_num=7),
Variable(name='another_df', line_num=9),
]
self.assertListEqual(visitor.created_dataframes, expected)
def test_df_header_description(self):
df = pd.DataFrame(
[
['United States', '$19.485 trillion', '2.27%', '325,084,756'],
['China', '$12.238 trillion', '6.90%', '1,421,021,791']
],
columns=['State', 'GDP', 'Growth Rate', 'Population'],
)
text = schema_utils.generate_df_header_description(
df, name='df_country')
expected_text = """
# Columns in df_country with example values:
# State (United States), GDP ($19.485 trillion), Growth Rate (2.27%), Population (325,084,756)
""".lstrip()
self.assertEqual(text, expected_text)
text = schema_utils.generate_df_header_description(
df, name='df_country', max_column_num=3)
expected_text = """
# First 3 columns in df_country with example values:
# State (United States), GDP ($19.485 trillion), Growth Rate (2.27%)
""".lstrip()
self.assertEqual(text, expected_text)
def test_df_schema_description_multiple_examplars(self):
text = schema_utils.generate_df_header_description(
EXAMPLE_DF,
name='df_country',
template=' {column_name} (dtype {dtype}): {value}',
num_examples=2
)
expected_text = """
# Columns in df_country with up to 2 example values:
# State (dtype string): United States, China
# GDP (dtype string): $19.485 trillion, $12.238 trillion
# Growth Rate (dtype string): 2.27%, 6.90%
# Population (dtype string): 325,084,756, 1,421,021,791
""".lstrip()
self.assertContainsSubsequence(text, 'United States')
self.assertEqual(text, expected_text)
def test_get_schema_summary_text_for_dataframe(self):
cells = [
"""import pandas as pd""",
"""
df = pd.DataFrame(
[
['United States', '$19.485 trillion', '2.27%', '325,084,756'],
['China', '$12.238 trillion', '6.90%', '1,421,021,791']
],
columns=['State', 'GDP', 'Growth Rate', 'Population']
)
""".strip(),
"""
# A comment
result = df.sort_values(by='GDP')
""".strip(),
]
schema_info = schema_utils.extract_schema_information_from_code(
cells,
schema_representation_config=SchemaRepresentationConfig(
variable_location=VariableLocation.INTERMEDIATE,
style=VariableStateTextStyle.HEADER_DESCRIPTION
)
)
self.assertLen(schema_info, 2)
self.assertEqual(schema_info[0]['df_variables'][0].name, 'df')
self.assertEqual(schema_info[1]['df_variables'][0].name, 'result')
def test_inline_schema_representation(self):
code = """
import pandas as pd
df = pd.DataFrame(
[
['United States', '$19.485 trillion', '2.27%', '325,084,756'],
['China', '$12.238 trillion', '6.90%', '1,421,021,791']
],
columns=['State', 'GDP', 'Growth Rate', 'Population']
)
result = df.sort_values(by='GDP').head(1)
result_2 = result.head(2)
series = result.GDP.apply(lambda x: x[1:4])
# Annotation of this line is not supported yet.
df['GDP'] = series
""".strip()
code_cell_2 = """
df['GDP_2'] = series
"""
schema_info_list = schema_utils.extract_schema_information_from_code(
[code, code_cell_2],
schema_representation_config=SchemaRepresentationConfig(
variable_location=VariableLocation.INTERMEDIATE,
location=VariableStateTextLocation.INLINE,
style=VariableStateTextStyle.HEADER_DESCRIPTION,
)
)
modified_code = schema_utils.inline_schema_representation(
code,
schema_info_list[0]
)
print(modified_code)
for segments in [
"""
# Columns in df with example values:
# State (United States), GDP (12.), Growth Rate (2.27%), Population (325,084,756)
df = pd.DataFrame(
""".strip(),
"""
# Columns in result with example values:
# State (China), GDP ($12.238 trillion), Growth Rate (6.90%), Population (1,421,021,791)
result = df.sort_values(by='GDP').head(1)
""".strip(),
"""
series = result.GDP.apply(lambda x: x[1:4])
""".rstrip()
]:
self.assertIn(segments, modified_code)
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for utils."""
from absl.testing import absltest
from arcade_nl2code.annotated_dataset import utils
DUMMY_NOTEBOOK_CELLS = [
{'cell_type': 'code', 'source': 'code line'},
{'cell_type': 'markdown', 'source': '## this is a markdown line.'},
{'cell_type': 'code', 'source': 'another code line'},
]
class UtilsTest(absltest.TestCase):
def test_markdown_to_text(self):
source = '# Here is a test markdown with [link](http://foo.bar.com).'
text = 'Here is a test markdown with link.'
self.assertEqual(utils.markdown_to_text(source), text)
def test_notebook_searilization_default_format(self):
code = utils.notebook_to_python(DUMMY_NOTEBOOK_CELLS)
expected_code = """
# In[ ]:
code line
# In[ ]:
# ## this is a markdown line.
# In[ ]:
another code line
""".strip()
self.assertEqual(code, expected_code)
def test_notebook_searilization_vscode_format(self):
code = utils.notebook_to_python(
DUMMY_NOTEBOOK_CELLS, cell_marker_style='vscode')
expected_code = """
# %%
code line
# %%[markdown]
# ## this is a markdown line.
# %%
another code line
""".strip()
self.assertEqual(code, expected_code)
def test_notebook_searilization_vscode_custom_format(self):
code = utils.notebook_to_python(
DUMMY_NOTEBOOK_CELLS, cell_marker_style='vscode_custom')
expected_code = """
# %%[code]
code line
# %%[markdown]
# ## this is a markdown line.
# %%[code]
another code line
""".strip()
self.assertEqual(code, expected_code)
def test_notebook_serialization_roundtrip(self):
code = utils.notebook_to_python(
DUMMY_NOTEBOOK_CELLS,
cell_marker_style='vscode_custom',
comment_markdown_cell=False)
expected_code = """
# %%[code]
code line
# %%[markdown]
## this is a markdown line.
# %%[code]
another code line
""".strip()
self.assertEqual(code, expected_code)
nb = utils.source_to_notebook(code)
self.assertEqual(len(nb.cells), len(DUMMY_NOTEBOOK_CELLS))
for original_cell, cell in zip(DUMMY_NOTEBOOK_CELLS, nb.cells):
self.assertEqual(original_cell['cell_type'], cell['cell_type'])
self.assertEqual(original_cell['source'], cell['source'])
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for output_spec_utils."""
from absl.testing import absltest
from arcade_nl2code.annotated_dataset import output_spec_utils
class OutputSpecUtilsTest(absltest.TestCase):
def test_get_output_variables_spec(self):
spec = output_spec_utils.get_program_output_variables_spec(
"""
import pandas as pd
""",
"""
df = pd.DataFrame([{'a': '1', 'b': '2'}, {'a': '2', 'b': '3'}])
print(df.value_counts())
df.value_counts()
# df.head(2)
"""
)
print('Spec is', spec)
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=line-too-long
r"""Generate few-shot learning datasets with schema information.
"""
# pylint: enable=line-too-long
import copy
import dataclasses
import functools
import gc
import json
import os
import pathlib
from typing import Any, Callable, Dict, List, Optional, Text, Tuple
from absl import app
from absl import flags
from absl import logging
from ipython_genutils import ipstruct
import nbformat
import seqio
import tqdm
from arcade_nl2code.evaluation import dataset as dataset_module # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import output_spec_utils # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import prompt_utils # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import schema_utils # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import utils # pylint: disable=g-bad-import-order
_DATASET_FLAG = flags.DEFINE_string(
'dataset', None, 'Path to the original dataset', required=True)
_OUTPUT_FOLDER_FLAG = flags.DEFINE_string(
'output_folder', None, 'Path to the folder to save output datasets.')
_OUTPUT_DATASET_NAME_FLAG = flags.DEFINE_string(
'output_dataset_name', None, 'File name of the generated dataset.')
_RUNTIME_ARTIFACTS_ROOT_FLAG = flags.DEFINE_string(
'runtime_artifacts_root', None, 'Path to runtime dependencies')
_SCHEMA_REPRESENTATION_METHOD_FLAG = flags.DEFINE_string(
'schema_representation_method',
'originating_dfs.header_description.after_last_variable_cell',
help=('String-represented configuration to define '
'how dataframe schemas are represented in prompts.'))
_USE_SCHEMA_IN_PROMPT_FLAG = flags.DEFINE_bool(
'use_schema_in_prompt',
True,
help=(
'A flag used for debugging purpose. '
'Turning it off will not include schema information in prompts,'
'while the prompt length is the same as the default.'))
_LINEARIZE_KWARGS_FLAG = flags.DEFINE_string(
'linearize_kwargs', '{}',
help='Json-serized dict of extra cell linearization arguments.')
_MAX_PROMPT_SIZE_FLAG = flags.DEFINE_integer(
'max_prompt_size', 5000, help='Max prompt length.')
_MAX_NOTEBOOK_CONTEXT_LEN_FLAG = flags.DEFINE_integer(
'max_notebook_context_len', -1,
help='Max notebook context length. Only used for prompting with exemplars.')
_MAX_CONTEXT_CELL_NUM_FLAG = flags.DEFINE_list(
'max_context_cell_num', [], help='List of max number of context cells.')
_VOCAB_PATH_FLAG = flags.DEFINE_string(
'vocab_path', None,
help='Path to seqio vocabulary.')
_TRUNCATE_METADATA_PATH_FLAG = flags.DEFINE_string(
'truncate_metadata_path', None,
help='Path to the metadata file that records prompt length information.')
_FILE_SUFFIX_FLAG = flags.DEFINE_string(
'file_suffix', '',
help='Suffix label to append to generated dataset file name.')
_ADD_EXEMPLARS_FLAG = flags.DEFINE_bool(
'add_exemplars', False,
help='Pre-pend exemplars to prompt for explanation-based prompting')
_EXEMPLAR_NOTEBOOK_FLAG = flags.DEFINE_string(
'exemplar_notebook', None,
help='Path to the template notebook with exemplars.')
_EXEMPLAR_INDEX_FLAG = flags.DEFINE_multi_string(
'exemplar_index', ['0,1,2,3'],
help='Common separated list of exemplar indices to use in prompts.')
_FORMAT_CONFIGS_FLAG = flags.DEFINE_list(
'format_configs', ['step+explanation'],
help='List of format configs to generate datasets.')
_EXEMPLAR_USE_SCHEMA_REPRESENTATION_FLAG = flags.DEFINE_bool(
'exemplar_use_schema_representation', True,
help='Whether to use inlined schema representations for exemplars.')
_APPEND_OUTPUT_SPEC_FLAG = flags.DEFINE_bool(
'append_output_spec', False,
help='Whether to append output specification.')
_OUTPUT_SPEC_LOCATION_FLAG = flags.DEFINE_enum(
'output_spec_location', 'both', ['exemplars_only', 'both'],
help='Locations to insert output specifications.')
_WRITE_FILE_PATH_TO_FLAG = flags.DEFINE_string(
'write_file_path_to', None,
help='Write generated dataset file paths to a file.')
LmExample = dataset_module.LmExample
Turn = dataset_module.Turn
Cell = ipstruct.Struct
VariableType = schema_utils.VariableType
VariableLocation = schema_utils.VariableLocation
VariableStateTextLocation = schema_utils.VariableStateTextLocation
VariableStateTextStyle = schema_utils.VariableStateTextStyle
SchemaRepresentationConfig = schema_utils.SchemaRepresentationConfig
def get_text_size(
text: Text,
vocabulary: seqio.SentencePieceVocabulary
) -> int:
"""Get tokenized text length."""
return len(vocabulary.encode(text))
def generate_schema_augmented_prompt(
turn_example: LmExample,
vocabulary: Optional[seqio.Vocabulary],
schema_representation_config: Optional[SchemaRepresentationConfig],
schema_info: List[schema_utils.CellSchemaInfo],
output_spec: Text = None,
cell_linearize_func_kwargs: Optional[Dict[Text, Any]] = None,
max_prompt_size: int = 0,
max_prompt_size_excluding_prefix: int = 0,
max_context_cell_num: int = -1,
prompt_prefix: Optional[Text] = None,
intent_postprocess_fn: Optional[prompt_utils.IntentPostprocessFn] = None,
prompt_postprocess_fn: Optional[Callable[[Text, LmExample], Text]] = None,
use_schema_augmented_prompt: bool = True,
truncation_metadata: Optional[Dict[Text, Any]] = None,
) -> Tuple[Text, Dict[Text, Any]]:
"""Generate schema-augmented prompt for one example.
Args:
turn_example: A natural language to code example turn.
vocabulary: SentencePieceVocabulary for sub-tokenization.
schema_representation_config: How dataframe schemas are represented in
prompts.
schema_info: List of cell schema information.
output_spec: Output specification to be appended to the intent.
cell_linearize_func_kwargs: Kwargs passed to the function that converts
notebook cells to textual prompts.
max_prompt_size: Max sub-tokenized size of the prompt.
max_prompt_size_excluding_prefix: Max size of testing notebook context,
excluding the size of format exemplars.
max_context_cell_num: Max number of cells from test notebook context to be
included in prompts.
prompt_prefix: Text of format exemplars to be appended in prompts.
intent_postprocess_fn: Post-process function to modify intents before Adding
them to prompts.
prompt_postprocess_fn: Post-process function of the final generated prompts.
use_schema_augmented_prompt: Whether to return the schema-augmented prompt.
truncation_metadata: Metadata dict to truncate generated prompt.
Returns:
A tuple of generated prompt with a dict of metadata.
"""
context_cells = utils.split_to_cells(turn_example.input)
first_cell_idx = len(context_cells) - 1
context_cell_num = 1
modified_prompt = prompt_prefix or ''
intent_text = turn_example.turn.intent.value
intent_postprocess_fn = intent_postprocess_fn or (lambda x, _: x)
# Starting from the last cell, at each iteration, grow context size by
# including one preceding cell. For the list of cells in context, inline
# with variable state information. Continue if the modified context is shorter
# than the max prompt size.
while first_cell_idx >= 0:
turn_context_cells = context_cells[first_cell_idx: ]
# Insert schema representation text.
if schema_info:
schema_augmented_turn_context_cells = schema_utils.insert_schema_representations_to_cells( # pylint: disable=line-too-long
turn_context_cells,
start_cell_idx=first_cell_idx,
schema_info=schema_info,
schema_representation_config=schema_representation_config,
turn_example=turn_example
)
if intent_postprocess_fn:
# Intent is the last cell in `turn_example.input`.
intent_text = context_cells[-1]
if output_spec:
intent_text_no_output_spec = turn_example.turn.metadata.get(
'utterance_without_output_spec')
intent_text = intent_text_no_output_spec or intent_text
intent_text = output_spec_utils.append_output_spec(
intent_text, output_spec)
intent_text = intent_postprocess_fn(intent_text, turn_example)
if not intent_text.startswith('#'):
intent_text = '# ' + intent_text
if intent_text:
schema_augmented_turn_context_cells[-1] = intent_text
turn_context_cells[-1] = intent_text
else:
# Delete the intent cell if it intent is empty.
del schema_augmented_turn_context_cells[-1]
del turn_context_cells[-1]
notebook_context_part = prompt_utils.cells_to_prompt(
schema_augmented_turn_context_cells, **cell_linearize_func_kwargs)
if not use_schema_augmented_prompt:
notebook_context_part_no_schema = prompt_utils.cells_to_prompt(
turn_context_cells,
**cell_linearize_func_kwargs)
if prompt_prefix:
candidate_prompt = prompt_utils.concat(
prompt_prefix, notebook_context_part,
**cell_linearize_func_kwargs)
if not use_schema_augmented_prompt:
candidate_prompt_no_schema = prompt_utils.concat(
prompt_prefix, notebook_context_part_no_schema,
**cell_linearize_func_kwargs)
else:
candidate_prompt = notebook_context_part
if not use_schema_augmented_prompt:
candidate_prompt_no_schema = notebook_context_part_no_schema
if prompt_postprocess_fn:
candidate_prompt = prompt_postprocess_fn(candidate_prompt, turn_example)
if not use_schema_augmented_prompt:
candidate_prompt_no_schema = prompt_postprocess_fn(
candidate_prompt_no_schema, turn_example)
if vocabulary and (
max_prompt_size > 0 or max_prompt_size_excluding_prefix > 0
):
notebook_context_part_length = get_text_size(
notebook_context_part, vocabulary)
candidate_prompt_length = get_text_size(candidate_prompt, vocabulary)
if (
0 < max_prompt_size < candidate_prompt_length or
0 < max_prompt_size_excluding_prefix < notebook_context_part_length
):
if first_cell_idx == len(context_cells) - 1:
logging.warning(
'No complete cell is included in the prompt. '
'Will trim down the last cell to fit into the '
'prompt.')
modified_prompt = candidate_prompt[-max_prompt_size:]
if not use_schema_augmented_prompt:
modified_prompt = candidate_prompt_no_schema
else:
logging.warning(
'Cut down cells up to index %d, target intent at cell %d',
first_cell_idx + 1, len(context_cells) - 1)
current_context_cell_num = len(context_cells) - first_cell_idx - 1
if current_context_cell_num < max_context_cell_num:
logging.warning(
'Not all cells up to `max_context_cell_num` is included.'
'context_cell_num: %d, '
'max_context_cell_num: %d',
context_cell_num,
max_context_cell_num)
break
elif truncation_metadata:
current_prompt_char_num = len(candidate_prompt)
if not use_schema_augmented_prompt:
current_prompt_char_num = len(candidate_prompt_no_schema)
if current_prompt_char_num > truncation_metadata['prompt_char_num']:
break
modified_prompt = candidate_prompt
if not use_schema_augmented_prompt:
modified_prompt = candidate_prompt_no_schema
context_cell_num = len(context_cells) - first_cell_idx
if 0 <= max_context_cell_num <= context_cell_num:
break
first_cell_idx -= 1
metadata = dict(
context_cell_num=context_cell_num,
intent_text=intent_text,
first_cell_index=len(context_cells) - context_cell_num,
)
if max_prompt_size > 0:
prompt_length = (
get_text_size(modified_prompt, vocabulary)
if vocabulary else truncation_metadata['prompt_length'])
assert prompt_length <= max_prompt_size
metadata['prompt_length'] = prompt_length
return modified_prompt, metadata
def generate_dataset(
dataset_file: Text,
output_path: Text,
output_dataset_name: Optional[Text] = None,
runtime_artifacts_root: Optional[Text] = None,
schema_representation_config_string: Text = 'df_columns.after_variable_cell',
variable_verbalizer_kwargs: Optional[Dict[Text, Any]] = None,
cell_linearize_func_kwargs: Optional[Dict[Text, Any]] = None,
max_prompt_size: int = -1,
max_prompt_size_excluding_prefix: int = -1,
max_context_cell_num: int = -1,
vocab_path: Optional[Text] = None,
prompt_truncation_metadata_file: Optional[Text] = None,
prompt_prefix: Optional[Text] = None,
intent_postprocess_fn: Optional[prompt_utils.IntentPostprocessFn] = None,
prompt_postprocess_fn: Optional[Callable[[Text, LmExample], Text]] = None,
append_output_spec: bool = False,
file_suffix: Text = '',
first: int = -1,
skip_exists: bool = False,
ignore_errors: bool = False
) -> Tuple[List[Dict[Text, Any]], Text]:
"""Generate a dataset for prompt learning from a notebooks NL2Code dataset.
Args:
dataset_file: Path to the original dataset.
output_path: Path to the output folder of the generated dataset.
output_dataset_name: Optional file name of the generated dataset.
runtime_artifacts_root: Path to dependency files to execute examples.
schema_representation_config_string: String-represented configuration to
define how dataframe schemas are represented in prompts. See
`SchemaRepresentationConfig.from_string` for more details.
variable_verbalizer_kwargs: Kwargs passed to the verbalizer that linearizes
schema representations to textual descriptions in prompts.
cell_linearize_func_kwargs: Kwargs passed to the function that converts
notebook cells to textual prompts.
max_prompt_size: Max sub-tokenized size of the prompt.
max_prompt_size_excluding_prefix: Max size of testing notebook context,
excluding the size of format exemplars.
max_context_cell_num: Max number of cells from test notebook context to be
included in prompts.
vocab_path: Path to SentencePieceVocabulary for sub-tokenization.
prompt_truncation_metadata_file: Path to the metadata file that stores
prompt length. Used as an alternative to vocabulary.
prompt_prefix: Text of format exemplars to be appended in prompts.
intent_postprocess_fn: Post-process function to modify intents before Adding
them to prompts.
prompt_postprocess_fn: Post-process function of the final generated prompts.
append_output_spec: Whether to append output specification to intents.
file_suffix: Suffix labels of the output dataset file name.
first: Only generate the dataset for the first N examples in the dataset.
skip_exists: Whether to skip the generation of an existing dataset saved
on disk.
ignore_errors: Whether to ignore notebook execution errors.
Returns:
A tuple of the generated dataset and its output file path.
"""
if not output_dataset_name:
output_dataset_name = pathlib.Path(dataset_file).with_suffix(
f'.+schema.{schema_representation_config_string}'
f'.maxp{max_prompt_size}'
f'.maxp_no_prefix{max_prompt_size_excluding_prefix}'
f'.maxctxcell{max_context_cell_num}'
f'{("." + file_suffix) if file_suffix else ""}.json'
).name
save_path = pathlib.Path(output_path) / output_dataset_name
schema_representation_config = None
if schema_representation_config_string:
schema_representation_config = SchemaRepresentationConfig.from_string(
schema_representation_config_string)
print(f'Save to {save_path.name}')
if skip_exists and save_path.exists():
print(f'Skipping existing dataset file {save_path.name}')
return None
dataset = dataset_module.load_dataset(dataset_file)
if first > 0:
dataset = dataset[:first]
cell_linearize_func_kwargs = cell_linearize_func_kwargs or {}
vocabulary = None
prompt_truncation_metadata = None
if vocab_path:
vocabulary = seqio.SentencePieceVocabulary(vocab_path)
if prompt_prefix:
prompt_prefix_size = get_text_size(prompt_prefix, vocabulary)
logging.info('Prompt prefix size: %d', prompt_prefix_size)
if 0 < max_prompt_size < prompt_prefix_size:
raise ValueError('Promt prefix too large.')
if max_prompt_size_excluding_prefix > 0 and max_prompt_size > 0:
if (
max_prompt_size_excluding_prefix + prompt_prefix_size >
max_prompt_size
):
raise ValueError(
'The combined size of prompt prefix and notebook context '
'cannot exceed max prompt size.')
else:
if (
max_prompt_size > 0 or
max_prompt_size_excluding_prefix > 0
):
if not prompt_truncation_metadata_file:
raise ValueError(
'Must provide either a vocabulary or a truncation metadata file.')
prompt_truncation_metadata = json.load(
open(prompt_truncation_metadata_file))
schema_augmented_dataset = []
schema_info_fs = None
if schema_representation_config:
if not runtime_artifacts_root:
raise ValueError('Must specify runtime_artifacts_root.')
schema_info_fs = schema_utils.extract_schema_information_parallel(
dataset,
runtime_artifacts_root=runtime_artifacts_root,
schema_representation_config=schema_representation_config,
verbalizer_kwargs=variable_verbalizer_kwargs,
ignore_errors=ignore_errors
)
output_spec_fs = None
if append_output_spec:
output_spec_fs = output_spec_utils.infer_program_output_spec_parallel(
dataset, runtime_artifacts_root=runtime_artifacts_root)
for episode_idx, episode in enumerate(
tqdm.tqdm(dataset, desc='Generating dataset')
):
notebook_name = episode['notebook_name']
modified_turn_examples = []
turn_example: LmExample
for turn_idx, turn_example in enumerate(episode['turns']):
# Find the schema information of this turn.
schema_info = None
schema_info_future_key = (
f'{notebook_name}_episode{episode_idx}_turn{turn_idx}')
if schema_representation_config:
schema_info: List[schema_utils.CellSchemaInfo] = schema_info_fs[
schema_info_future_key].result()
output_spec = None
if append_output_spec:
output_spec_future_key = (
f'{notebook_name}_episode{episode_idx}_turn{turn_idx}')
output_spec = output_spec_fs[output_spec_future_key].result()
modified_prompt, metadata = generate_schema_augmented_prompt(
turn_example,
schema_representation_config=schema_representation_config,
schema_info=schema_info,
output_spec=output_spec,
prompt_prefix=prompt_prefix,
vocabulary=vocabulary,
truncation_metadata=prompt_truncation_metadata[episode_idx][turn_idx],
intent_postprocess_fn=intent_postprocess_fn,
prompt_postprocess_fn=prompt_postprocess_fn,
cell_linearize_func_kwargs=cell_linearize_func_kwargs,
max_prompt_size_excluding_prefix=max_prompt_size_excluding_prefix,
max_prompt_size=max_prompt_size,
max_context_cell_num=max_context_cell_num,
use_schema_augmented_prompt=_USE_SCHEMA_IN_PROMPT_FLAG.value,
)
if not modified_prompt and not ignore_errors:
raise ValueError('Prompt is empty.')
modified_turn_example = copy.deepcopy(turn_example)
modified_turn_example.input = modified_prompt
modified_turn_example.turn.intent.value = metadata['intent_text']
modified_turn_example.metadata = modified_turn_example.metadata or dict()
modified_turn_example.metadata.update(metadata)
if schema_representation_config:
turn_schema_info_record = (
schema_utils.copy_schema_info_list_without_variable_values(
schema_info))
modified_turn_example.metadata['schema_info'] = turn_schema_info_record
modified_turn_examples.append(modified_turn_example)
if schema_info and schema_representation_config:
# De-reference objects that store execution results to save memory.
del schema_info
del schema_info_fs[schema_info_future_key]
modified_episode = dict(episode)
modified_episode['turns'] = modified_turn_examples
schema_augmented_dataset.append(modified_episode)
# Explicitly call garbage collection to save memory.
if (episode_idx + 1) % 5 == 0:
gc.collect()
save_path.parent.mkdir(parents=True, exist_ok=True)
json.dump(
schema_augmented_dataset,
save_path.open('w'),
cls=utils.DataclassJsonEncoder,
indent=2)
return (schema_augmented_dataset, str(save_path))
def generate_schema_augmented_prompt_main(
max_context_cell_num: int = -1,
):
"""Generate schema-augmented dataset without format exemplars."""
schema_representation_method = _SCHEMA_REPRESENTATION_METHOD_FLAG.value
max_prompt_size = _MAX_PROMPT_SIZE_FLAG.value
suffix = _FILE_SUFFIX_FLAG.value
_, generated_dataset_path = generate_dataset(
dataset_file=_DATASET_FLAG.value,
output_path=(
_OUTPUT_FOLDER_FLAG.value or os.path.dirname(_DATASET_FLAG.value)),
output_dataset_name=_OUTPUT_DATASET_NAME_FLAG.value,
runtime_artifacts_root=_RUNTIME_ARTIFACTS_ROOT_FLAG.value,
vocab_path=_VOCAB_PATH_FLAG.value,
prompt_truncation_metadata_file=_TRUNCATE_METADATA_PATH_FLAG.value,
max_context_cell_num=max_context_cell_num,
skip_exists=False,
schema_representation_config_string=schema_representation_method,
cell_linearize_func_kwargs=json.loads(_LINEARIZE_KWARGS_FLAG.value),
max_prompt_size=max_prompt_size,
max_prompt_size_excluding_prefix=-1,
prompt_prefix=None,
append_output_spec=_APPEND_OUTPUT_SPEC_FLAG.value,
file_suffix=f'schema_only{suffix}',
)
if _WRITE_FILE_PATH_TO_FLAG.value:
with open(_WRITE_FILE_PATH_TO_FLAG.value, 'a') as f:
f.write(generated_dataset_path + '\n')
def generate_datasets_varying_context_size():
"""Generate schema-augmented datasets with varying context size."""
for max_context_cell_num in _MAX_CONTEXT_CELL_NUM_FLAG.value:
generate_schema_augmented_prompt_main(
max_context_cell_num=int(max_context_cell_num))
def generate_prompt_with_exemplars_main():
"""Generate datasets with exemplars at the beginning of prompts."""
if _MAX_CONTEXT_CELL_NUM_FLAG.value:
raise ValueError('Parameter not supported.')
format_configs = _FORMAT_CONFIGS_FLAG.value
max_prompt_size = _MAX_PROMPT_SIZE_FLAG.value
schema_representation_config = SchemaRepresentationConfig.from_string(
_SCHEMA_REPRESENTATION_METHOD_FLAG.value)
exemplar_schema_config = (
schema_representation_config
if _EXEMPLAR_USE_SCHEMA_REPRESENTATION_FLAG.value
else None
)
if schema_representation_config.location == VariableStateTextLocation.AFTER_LAST_VARIABLE_CELL: # pylint: disable=line-too-long
exemplar_schema_config = dataclasses.replace(
schema_representation_config,
location=VariableStateTextLocation.AFTER_VARIABLE_CELL)
cell_linearize_func_kwargs = json.loads(_LINEARIZE_KWARGS_FLAG.value)
prompt_exemplars_nb = nbformat.read(
open(_EXEMPLAR_NOTEBOOK_FLAG.value),
as_version=4
)
vocabulary = None
if _VOCAB_PATH_FLAG.value:
vocabulary = seqio.SentencePieceVocabulary(_VOCAB_PATH_FLAG.value)
# Dict of format groups to their prompt prefixes, with metadata.
prompt_prefixes: Dict[Text, Dict[Text, Any]] = dict()
for exemplar_idx_key in _EXEMPLAR_INDEX_FLAG.value:
exemplar_ids = [int(x) for x in exemplar_idx_key.split(',')]
for config_name in format_configs:
format_config = prompt_utils.EXEMPLAR_FORMAT_CONFIGS[config_name]
prompt_prefix = prompt_utils.get_exemplars_part_in_prompt(
prompt_exemplars_nb,
exemplar_type=format_config['exemplar_type'],
exemplar_indices=exemplar_ids,
intent_postprocess_fn=format_config['intent_postprocess_fn'],
response_postprocess_fn=format_config.get(
'response_postprocess_fn', lambda x: x),
append_output_spec=_APPEND_OUTPUT_SPEC_FLAG.value,
schema_representation_config=exemplar_schema_config,
variable_verbalizer_kwargs=format_config.get(
'variable_verbalizer_kwargs', {}),
textify_func_kwargs=cell_linearize_func_kwargs,
)
# TODO(pcyin): add delimeter
prompt_prefix_size = None
if vocabulary:
prompt_prefix_size = get_text_size(prompt_prefix, vocabulary)
prompt_prefixes.setdefault(config_name, dict())
prompt_prefixes[config_name][exemplar_idx_key] = {
'value': prompt_prefix,
'size': prompt_prefix_size,
}
minimal_notebook_context_len = 900
max_notebook_context_len = _MAX_NOTEBOOK_CONTEXT_LEN_FLAG.value
if vocabulary:
# pylint: disable=g-complex-comprehension
longest_prompt_prefix_size = max(
metadata['size']
for format_group_prefixes in prompt_prefixes.values()
for metadata in format_group_prefixes.values()
)
# pylint: enable=g-complex-comprehension
if max_notebook_context_len > 0:
# Make sure these is enough space to fit in the prompt prefix with
# format exemplars.
if max_prompt_size - max_notebook_context_len < longest_prompt_prefix_size: # pylint: disable=line-too-long
raise ValueError(
f'There isn\'t enough space to fit test notebook context.'
f'Max prompt size: {max_prompt_size}, '
f'Max notebook context length: {max_notebook_context_len}, '
f'Longest prompt prefix size: {longest_prompt_prefix_size}')
else:
assert (
minimal_notebook_context_len <=
max_prompt_size - longest_prompt_prefix_size
)
logging.info(
'Total context window size %d, notebook context size %d',
max_prompt_size, max_notebook_context_len)
generate_dataset_fn = functools.partial(
generate_dataset,
dataset_file=_DATASET_FLAG.value,
output_path=(
_OUTPUT_FOLDER_FLAG.value or os.path.dirname(_DATASET_FLAG.value)),
output_dataset_name=_OUTPUT_DATASET_NAME_FLAG.value,
runtime_artifacts_root=_RUNTIME_ARTIFACTS_ROOT_FLAG.value,
vocab_path=_VOCAB_PATH_FLAG.value,
prompt_truncation_metadata_file=_TRUNCATE_METADATA_PATH_FLAG.value,
schema_representation_config_string=(
_SCHEMA_REPRESENTATION_METHOD_FLAG.value),
append_output_spec=(
_APPEND_OUTPUT_SPEC_FLAG.value and
_OUTPUT_SPEC_LOCATION_FLAG.value == 'both'),
max_prompt_size=max_prompt_size,
max_prompt_size_excluding_prefix=max_notebook_context_len,
max_context_cell_num=-1,
first=5 if 'debug' in _FILE_SUFFIX_FLAG.value else -1,
skip_exists=False,
)
generated_dataset_paths = []
for exemplar_idx_key in _EXEMPLAR_INDEX_FLAG.value:
logging.info(exemplar_idx_key)
exemplar_file_suffix = 'e' + exemplar_idx_key.replace(',', '_')
if _FILE_SUFFIX_FLAG.value:
exemplar_file_suffix = (f'{_FILE_SUFFIX_FLAG.value}.'
f'{exemplar_file_suffix}')
for config_name in format_configs:
format_config = prompt_utils.EXEMPLAR_FORMAT_CONFIGS[config_name]
prompt_prefix = prompt_prefixes[config_name][exemplar_idx_key]['value']
file_suffix = f'{exemplar_file_suffix}.{config_name}'
_, generated_dataset_path = generate_dataset_fn(
prompt_prefix=prompt_prefix,
variable_verbalizer_kwargs=format_config.get(
'variable_verbalizer_kwargs', {}),
cell_linearize_func_kwargs=format_config.get(
'cell_linearize_func_kwargs', cell_linearize_func_kwargs),
intent_postprocess_fn=format_config.get(
'intent_postprocess_fn', None),
prompt_postprocess_fn=format_config.get(
'prompt_postprocess_fn', None),
file_suffix=file_suffix,
)
generated_dataset_paths.append(generated_dataset_path)
if _WRITE_FILE_PATH_TO_FLAG.value:
with open(_WRITE_FILE_PATH_TO_FLAG.value, 'a') as f:
for generated_dataset_path in generated_dataset_paths:
f.write(generated_dataset_path + '\n')
def main(_):
if bool(_TRUNCATE_METADATA_PATH_FLAG.value) == bool(_VOCAB_PATH_FLAG.value):
raise ValueError(
'Only one of vocabulary or truncate_metaata path can be specified.')
if _ADD_EXEMPLARS_FLAG.value:
generate_prompt_with_exemplars_main()
elif _MAX_CONTEXT_CELL_NUM_FLAG.value:
generate_datasets_varying_context_size()
else:
generate_schema_augmented_prompt_main()
if __name__ == '__main__':
app.run(main)
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for dataset."""
import os
from absl.testing import absltest
from arcade_nl2code.annotated_dataset import dataset
LmExample = dataset.LmExample
Turn = dataset.Turn
Intent = dataset.Intent
Code = dataset.Code
DUMMY_DATASET = [
dict(
notebook_name='notebook_1.ipynb',
turns=[
LmExample(
input='Here is the prompt.',
turn=Turn(
Intent(
value='Test intent 1',
cell_idx=0,
line_span=(0, 2),
output_variables=['a', 'b']),
Code(value='a = b = 1', line_span=(1, 4))),
metadata=dict(
context_cells=[
{
'cell_type': 'code',
'source': 'import pandas as pd\nimport numpy as np',
},
],
delta_cell_num=1,
),
),
LmExample(
input='Here is another prompt.',
turn=Turn(
Intent(value='Test intent 2'), Code(value='a = b = 1')),
metadata=dict(
context_cells=[
{
'cell_type': 'code',
'source': 'some code',
},
],
delta_cell_num=1,
),
)
]
),
dict(
notebook_name='notebook_2.ipynb',
turns=[
LmExample(
input='Here is the 2nd prompt.',
turn=Turn(
Intent(value='Test intent 3'), Code(value='a = b = 1')))
])
]
class DatasetTest(absltest.TestCase):
def test_save_and_load_dataset(self):
output_dir = self.create_tempdir()
dataset_path = os.path.join(output_dir, 'dataset.json')
dataset.save_dataset(DUMMY_DATASET, dataset_path)
loaded_dataset = dataset.load_dataset(dataset_path)
self.assertListEqual(DUMMY_DATASET, loaded_dataset)
def test_convert_episode_to_notebook(self):
epsidoe = DUMMY_DATASET[0]
nb, metadata = dataset.episode_to_notebook(epsidoe)
expected_num_cells = len(epsidoe['turns']) * 2
self.assertLen(nb.cells, expected_num_cells + 2)
for turn_idx, turn_metadata in enumerate(metadata):
intent_cell = nb.cells[turn_metadata['intent_cell_idx']]
code_cell = nb.cells[turn_metadata['code_cell_idx']]
turn_example = epsidoe['turns'][turn_idx]
print(intent_cell)
self.assertEqual(intent_cell.source, turn_example.turn.intent.value)
print(code_cell)
self.assertEqual(code_cell.source, turn_example.turn.code.value)
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utility functions for parsing the annotated notebooks dataset."""
import dataclasses
import json
import pathlib
from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Union, NewType
from absl import logging
import dacite
import nbformat
from tensorflow.io import gfile
from arcade_nl2code.annotated_dataset import utils # pylint: disable=g-bad-import-order
EpisodePrediction = NewType('EpisodePrediction', Dict[Text, Any])
Cell = utils.Cell
def int_list_to_tuple(datum: Any, keys: List[Text]) -> Any:
"""Convert list in a pytree into tuple."""
if not isinstance(datum, dict):
return datum
new_datum = dict()
for key, val in datum.items():
new_val = val
if isinstance(val, list) and key in keys:
new_val = tuple(val)
else:
new_val = int_list_to_tuple(new_val, keys)
new_datum[key] = new_val
return new_datum
@dataclasses.dataclass
class Intent:
"""Represent an natural language intent."""
value: Optional[Text] = None
is_cell_intent: bool = False
cell_idx: Optional[int] = None
line_span: Optional[Tuple[int, int]] = None
not_sure: Optional[bool] = None
output_variables: Optional[List[Text]] = None
@property
def is_code_line_intent(self) -> bool:
return not self.is_cell_intent
@dataclasses.dataclass
class Code:
value: Text
cell_idx: Optional[int] = None
num_lines: int = 1
line_span: Optional[Tuple[int, int]] = None
@dataclasses.dataclass
class Turn:
"""A single turn of natural language intent and target code."""
intent: Intent
code: Code
# code context in order to execute any predicted program
code_context: Optional[Text] = None
# incremental code context between the previous turn and the current turn.
delta_code_context: Optional[Text] = None
# Optional metadata dict.
metadata: Optional[Dict[Text, Any]] = None
@classmethod
def from_dict(cls, datum: Dict[Text, Any]) -> 'Turn':
datum = int_list_to_tuple(datum, keys=['line_span'])
example = dacite.from_dict(
data_class=cls, data=datum)
return example
@dataclasses.dataclass
class LmExample:
"""An evaluation example, consiting of intent, code, and its code context."""
# Prompt to the language model, including the intent.
input: Text
turn: Turn
# back reference to the originating notebook.
notebook: Optional[nbformat.NotebookNode] = None
# Optional metadata dict.
metadata: Optional[Dict[Text, Any]] = None
@classmethod
def from_dict(cls, datum: Dict[Text, Any]) -> 'LmExample':
datum = int_list_to_tuple(datum, keys=['line_span'])
example = dacite.from_dict(
data_class=cls, data=datum)
return example
def save_dataset(
dataset: List[Dict[Text, Any]],
dataset_path: Union[Text, pathlib.Path]
):
with gfile.GFile(dataset_path, 'w') as f:
json.dump(
dataset,
f,
cls=utils.DataclassJsonEncoder,
indent=2
)
def load_dataset(
dataset_path: Union[Text, pathlib.Path]
) -> List[Dict[Text, Any]]:
"""Load annotated dataset to a list of dicts."""
examples = utils.load_json_or_jsonl_file(dataset_path)
for example in examples:
turn_examples = []
for turn_dict in example['turns']:
turn_example = LmExample.from_dict(turn_dict)
turn_examples.append(turn_example)
example['turns'] = turn_examples
return examples
def get_turn_tags(turn: Turn) -> List[Text]:
"""Get a list of tags of a turn."""
code = turn.code.value
# Is visualization code?
tags = []
if any(kwd in code
for kwd in ['.plot', '.bar(', '.hist(', 'sns.', 'plt.', 'boxplot(']):
tags.append('vis')
return tags
def load_predictions(
predictions_file: Union[pathlib.Path, Text],
lm_output_postprocessor_fn: Optional[Callable[[Text], Text]] = None
) -> List[EpisodePrediction]: # for each notebook
"""Load a model prediction file."""
episode_predictions = utils.load_json_or_jsonl_file(predictions_file)
# pylint: disable=unused-variable
for example_idx, episode_prediction in enumerate(episode_predictions):
assert 'notebook_name' in episode_prediction['metadata']
episode_hyp_list = episode_prediction['turns']
for turn_idx, turn_prediction in enumerate(episode_hyp_list):
example = LmExample.from_dict(
turn_prediction['metadata']['example'])
if lm_output_postprocessor_fn:
hyps = turn_prediction['predictions']
processed_hyps = []
hyp: Text
for hyp in hyps:
hyp = lm_output_postprocessor_fn(hyp)
processed_hyps.append(hyp)
turn_prediction['predictions'] = processed_hyps
# modify in-place
turn_prediction['metadata']['example'] = example
return episode_predictions
def episode_to_notebook(
episode: Dict[Text, Any]
) -> Tuple[nbformat.NotebookNode, List[Dict[Text, Any]]]:
"""Convert an annotated episode back to notebook."""
cells = []
annotation_metadata = []
turn_example: LmExample
for turn_example in episode['turns']:
turn_context_cells = turn_example.metadata['context_cells']
delta_cell_num = turn_example.metadata['delta_cell_num']
if delta_cell_num > 0:
delta_context_cells_before_turn = turn_context_cells[-delta_cell_num:]
cells.extend([
Cell(cell_type=cell['cell_type'], source=cell['source'])
for cell in delta_context_cells_before_turn
])
metadata = dict(
output_variables=turn_example.turn.intent.output_variables,
not_sure=turn_example.turn.intent.not_sure,
)
if turn_example.turn.metadata:
metadata.update({ # pylint: disable=g-complex-comprehension
k: v
for k, v in turn_example.turn.metadata.items()
if k in [
'annotator_id',
'utterance_without_output_spec',
]
})
intent_cell = Cell(
cell_type='markdown',
source=turn_example.turn.intent.value,
metadata=dict(
annotated=True,
type='intent',
**metadata,
),
)
code_cell = Cell(
cell_type='code',
source=turn_example.turn.code.value,
metadata=dict(
annotated=True,
type='code',
),
)
intent_cell_idx = len(cells)
cells.append(intent_cell)
code_cell_idx = len(cells)
cells.append(code_cell)
annotation_metadata.append({
'intent_cell_idx': intent_cell_idx,
'code_cell_idx': code_cell_idx,
**metadata,
})
return utils.to_notebook(cells), annotation_metadata
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for prompt_utils."""
from absl.testing import absltest
from ipython_genutils import ipstruct
import nbformat
from arcade_nl2code.annotated_dataset import prompt_utils # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import schema_utils # pylint: disable=g-bad-import-order
Cell = ipstruct.Struct
EXEMPLARS_TEMPLATE_CELLS = [
('code', """
import pandas as pd
import matplotlib.pyplot as plt
""".strip()),
('markdown', """
You are a professional data scientist. Answer the following questions using pandas and matplotlib.
""".strip()),
('markdown', """# Exercise 1"""),
('code', """
# Data Defination (score.csv)
df = pd.DataFrame([
{'name': 'John', 'score': 97},
{'name': 'Peter', 'score': 82},
{'name': 'Justin', 'score': 66},
])
""".strip()),
(
'markdown',
("""Task: Make a new column "grade" for letter grades """
"""(A: 90+, B: 70-90, C: <70) and plot the number of students """
"""in each grade.""")
),
('code', """
### Type: step
# Step 1: Define a function to convert scores to letter grades.
def get_grade(score):
if score >= 90:
return 'A'
elif 70 <= score < 90:
return 'B'
else:
return 'C'
# Step 2: Convert scores to letter grades.
df['grade'] = df.score.apply(get_grade)
# Step 3: Count the number of students by grade.
count_df = df['grade'].value_counts()
# Step 4: Visualize in a bar chart.
count_df.plot(kind='bar')
""".strip())
]
class PromptUtilsTest(absltest.TestCase):
def test_get_exemplars_part_in_prompt(self):
template_nb = self.cells_to_notebook()
schema_config_cls = schema_utils.SchemaRepresentationConfig
prompt_part = prompt_utils.get_exemplars_part_in_prompt(
template_nb,
exemplar_type='step',
schema_representation_config=schema_config_cls.from_string(
'originating_dfs.header_description.after_variable_cell'),
append_output_spec=True
)
print(prompt_part)
last_solution = EXEMPLARS_TEMPLATE_CELLS[-1][1]
solution_but_metadata_header = last_solution.removeprefix('### Type: step')
self.assertIn(solution_but_metadata_header, prompt_part)
self.assertIn("df = pd.read_csv('score.csv')", prompt_part)
self.assertIn('Schema of Dataframes:', prompt_part)
self.assertIn('Show a plot.', prompt_part)
prompt_part_no_schema_desc = prompt_utils.get_exemplars_part_in_prompt(
template_nb,
exemplar_type='step',
schema_representation_config=None,
append_output_spec=True
)
print(prompt_part_no_schema_desc)
def cells_to_notebook(self) -> nbformat.NotebookNode:
cells = []
for cell_type, source in EXEMPLARS_TEMPLATE_CELLS:
cell = Cell(cell_type=cell_type, source=source)
cells.append(cell)
return nbformat.NotebookNode(cells=cells)
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utility functions for notebook LM."""
import dataclasses
import json
import pathlib
import re
import types
from typing import Any, Dict, List, Optional, Text, Union, cast
import bs4
import nbconvert
import nbformat
from tensorflow.io import gfile
# pylint: disable=g-import-not-at-top
try:
import markdown # pytype: disable=import-error
except ImportError:
from markdown_freewisdom import markdown
class Cell(types.SimpleNamespace):
"""Represent a single notebook cell."""
def __getitem__(self, key: Text) -> Text:
if not hasattr(self, key):
raise KeyError(f'Unknown property {key}')
return getattr(self, key)
def __setitem__(self, key: Text, value: Text):
setattr(self, key, value)
def get(self, key: Text, default: Optional[Text] = None) -> Text:
return getattr(self, key, default)
def to_dict(self) -> Dict[Text, Text]:
return dict(
cell_type=self.cell_type,
source=self.source,
)
INCODER_SOURCE_HEADER = '<| file ext=.ipynb:python |>'
class DataclassJsonEncoder(json.JSONEncoder):
"""Custom json encoder for dataclasses and other Python objects."""
def default(self, o: Any) -> ...:
if dataclasses.is_dataclass(o):
return dataclasses.asdict(o)
elif isinstance(o, pathlib.Path):
return str(o)
elif isinstance(o, Cell):
return o.to_dict()
return super().default(o)
def load_json_or_jsonl_file(
file_path: Union[pathlib.Path, Text]
) -> List[Any]:
"""Read a list of datum from a json or jsonl file."""
examples = []
with gfile.GFile(str(file_path)) as f:
first_line = f.readline().strip()
f.seek(0)
file_format = 'json' if first_line == '[' else 'jsonl'
if file_format == 'jsonl':
for line in f:
data = json.loads(line)
examples.append(data)
else:
examples = cast(List[Any], json.load(f))
return examples
def markdown_to_text(text: str) -> str:
html = markdown.markdown(text)
text = bs4.BeautifulSoup(html, features='html.parser').get_text()
return text
def uncomment(source, prefix: Text = '# ') -> Text:
"""Very naive way of uncommenting markdown texts."""
lines = source.split('\n')
lines = [
line.removeprefix(prefix)
for line in lines
]
return '\n'.join(lines)
def notebook_to_python(
nb_or_cells: Union[nbformat.NotebookNode, List[Cell]],
cell_marker_style: str = 'nbconvert',
comment_markdown_cell: bool = True,
strip_cell_content: bool = True,
) -> Text:
"""Convert a notebook object to Python source."""
cell_source_list = []
cells = (
nb_or_cells
if isinstance(nb_or_cells, list)
else nb_or_cells.get('cells', []))
for cell in cells:
cell_content = ''
cell_type = cell.get('cell_type', None)
if cell_type == 'markdown':
cell_content = cell.get('source', '')
if strip_cell_content:
cell_content = cell_content.strip()
if cell_marker_style == 'incoder':
if comment_markdown_cell:
raise ValueError(
'Cannot use `comment_markdown_cell` when cell delimiter style '
'is InCoder')
# Uncomment markdown cells.
cell_content = uncomment(cell_content, prefix='# ')
elif comment_markdown_cell:
cell_content = nbconvert.filters.strings.comment_lines(
cell_content)
elif cell_type == 'code':
cell_content = cell.get('source', '')
if strip_cell_content:
cell_content = cell_content.strip()
if cell_marker_style == 'nbconvert':
cell_content = '# In[ ]:\n\n\n' + cell_content + '\n\n\n'
elif cell_marker_style == 'vscode':
prefix = '# %%[markdown]' if cell_type == 'markdown' else '# %%'
cell_content = prefix + '\n' + cell_content + '\n\n'
elif cell_marker_style == 'vscode_custom':
prefix = '# %%[markdown]' if cell_type == 'markdown' else '# %%[code]'
cell_content = prefix + '\n' + cell_content + '\n\n'
elif cell_marker_style == 'incoder':
if cell_type == 'code':
template = '<cell>\n{source}\n</cell>\n'
else:
template = '<text>\n{source}\n</text>\n'
cell_content = template.format(source=cell_content)
else:
raise ValueError(f'Unknown cell delimiter style: {cell_marker_style}')
cell_source_list.append(cell_content)
source = ''.join(cell_source_list)
source = source.strip()
if cell_marker_style == 'incoder':
source = INCODER_SOURCE_HEADER + '\n' + source
return source
def split_to_cells(code: Text) -> List[Text]:
"""Split concatenated context code to individual cells."""
cells = code.split('# In[ ]:')
# Skip empty cells before and after.
start = 0
while start < len(cells) and not cells[start].strip():
start += 1
end = len(cells) - 1
while end >= start and not cells[end].strip():
end -= 1
cells = cells[start: end + 1]
cells = [cell.strip() for cell in cells]
return cells
def remove_comments(code: Text) -> Text:
lines = [
line
for line in code.split('\n')
if not line.strip().startswith('#')
]
code = '\n'.join(lines).strip()
return code
def to_notebook(cells: List[Cell]) -> nbformat.NotebookNode:
"""Convert dummy notebook dict into a Notebook instance."""
processed_cells = []
for cell in cells:
cell = cell.to_dict()
if 'metadata' not in cell:
cell['metadata'] = {}
if cell == 'code':
cell['outputs'] = []
processed_cells.append(cell)
metadata = {
'kernelspec': {
'display_name': 'Python 3 (ipykernel)',
'language': 'python',
'name': 'python3'
},
'language_info': {
'codemirror_mode': {
'name': 'ipython',
'version': 3
},
'file_extension': '.py',
'mimetype': 'text/x-python',
'name': 'python',
'version': '3.8.10'
}
}
nb_dict = dict(cells=processed_cells, metadata=metadata, nbformat=4)
notebook = nbformat.from_dict(nb_dict)
return notebook
def source_to_notebook(
source: Text,
cell_marker_style: Text = 'vscode_custom',
markdown_cell_commented: bool = False,
) -> nbformat.NotebookNode:
"""Convert a Python source back to a notebook object."""
if cell_marker_style != 'vscode_custom':
raise ValueError(f'Unknown cell delimiter style: {cell_marker_style}')
if markdown_cell_commented:
raise ValueError('Does not support `markdown_cell_commented=True`')
markdown_dilimiter = '# %%[markdown]\n'
code_dilimiter = '# %%[code]\n'
cell_source_list = re.split(
r'(# %%\[markdown\]\n|# %%\[code\]\n)', source)
cell_source_list = cell_source_list[1:] # First entry is always empty.
cells: List[Cell] = []
for delimiter, source in zip(
cell_source_list[0::2],
cell_source_list[1::2]
):
assert delimiter in [markdown_dilimiter, code_dilimiter]
cell_type = 'markdown' if delimiter == markdown_dilimiter else 'code'
source = source.removesuffix('\n\n') # Only remove new lines in dilimiters.
cell = Cell(cell_type=cell_type, source=source)
cells.append(cell)
notebook = to_notebook(cells)
return notebook
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Generate few-shot learning datasets with schema information."""
# pylint: disable=missing-function-docstring
from concurrent import futures
import multiprocessing
import os
import re
import shutil
import string
from typing import Any, Dict, List, Text, Optional, Tuple
import uuid
from absl import logging
import numpy as np
import pandas as pd
import PIL
from arcade_nl2code.evaluation import dataset as dataset_module # pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import execution # pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import execution_evaluation # pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import variable_state_utils # pylint: disable=g-bad-import-order
LmExample = dataset_module.LmExample
Turn = dataset_module.Turn
EMPTY_STATE = variable_state_utils.DeltaExecutionState(states={})
def extract_reference_execution_state(
variables_before: Dict[Text, Any],
variables_after: Dict[Text, Any],
target_output_variables: Optional[List[Text]] = None
) -> Tuple[
variable_state_utils.DeltaExecutionState,
Dict[Text, Any]
]:
delta_state = variable_state_utils.extract_reference_execution_state(
variables_before, variables_after, target_output_variables)
metadata = dict()
if not target_output_variables:
# Only annotate output specification if the last line returns any output.
if '__output__' in delta_state.states:
if delta_state.states['__output__'].value is not None:
delta_state = variable_state_utils.DeltaExecutionState(
states=dict(__output__=delta_state.states['__output__']))
else:
delta_state = EMPTY_STATE
else:
delta_state = EMPTY_STATE
if len(delta_state.states) == 1:
output_var = next(iter(delta_state.states.values())).value
# If there existes another dataframe in the program state before and has
# the same schema as the output, then do not describe target columns
# in the NL specification.
if isinstance(output_var, pd.DataFrame):
column_names = [str(col) for col in output_var.columns]
for var in variables_before.values():
if isinstance(var, pd.DataFrame):
other_column_names = [str(col) for col in var.columns]
if column_names == other_column_names:
metadata = dict(describe_columns=False)
return delta_state, metadata
def canonicalize_code(code: Text) -> Text:
if 'iplot(' in code:
# Overload iplot.
code = re.sub(r'iplot\(.*?\)', 'pass', code)
code = code.replace('fig.show()', 'pass')
return code
def get_program_output_state(
context_code: Text,
target_code: Text,
output_variables: List[Text] = None
) -> Tuple[
Dict[Text, variable_state_utils.Variable],
Dict[Text, Any]
]:
"""Extract information about output variables."""
context_exec_globals = {}
if context_code:
context_code = canonicalize_code(context_code)
context_exec_state = execution.exec_wrapper(
context_code, context_exec_globals)
assert (not context_exec_state.error), context_exec_state.error_text
context_exec_globals_copy = execution.copy_variable_dict(
context_exec_globals)
target_code = canonicalize_code(target_code)
preprocessed_tgt_code = (
execution_evaluation
.CodeFormatterForTracing
.preprocess_code_for_tracing(target_code))
ref_trace_result = execution.exec_wrapper(
preprocessed_tgt_code,
exec_globals=context_exec_globals,
)
assert not ref_trace_result.error
exec_globals_before = context_exec_globals_copy
exec_globals_after = ref_trace_result.exec_globals
ref_execution_state, metadata = extract_reference_execution_state(
exec_globals_before, exec_globals_after,
output_variables)
return ref_execution_state.states, metadata
def get_variable_specification(
variable: Any,
describe_columns: bool = True
) -> Text:
"""Returns an NL description of variable type."""
output_spec = ''
if isinstance(variable, pd.DataFrame):
if describe_columns:
column_names = ', '.join([f'"{x}"' for x in variable.columns])
output_spec = (
f'dataframe with {variable.shape[1]} columns: '
f'{column_names}')
else:
output_spec = 'dataframe'
elif isinstance(variable, pd.Series):
if variable.name is not None:
output_spec = f'pandas series named "{variable.name}"'
elif variable.index is not None and variable.index.name is not None:
index_name = variable.index.name
output_spec = f'pandas series with index "{index_name}"'
elif variable.index is not None and variable.index.names is not None:
index_names = ', '.join(f'"{x}"' for x in variable.index.names)
output_spec = f'pandas series with indices {index_names}'
else:
output_spec = 'pandas series'
elif isinstance(variable, pd.Index):
output_spec = 'pandas index'
elif isinstance(variable, np.ndarray):
output_spec = 'numpy array'
elif isinstance(variable, np.generic):
output_spec = 'number'
elif isinstance(variable, (float, int)):
output_spec = 'number'
elif isinstance(variable, str):
output_spec = 'string'
elif isinstance(variable, bool):
output_spec = 'boolean'
elif isinstance(variable, list):
output_spec = 'list'
elif isinstance(variable, PIL.Image.Image):
output_spec = 'plot'
else:
output_spec = f'{type(variable).__name__} object'
return output_spec
def is_visualization_code(code: Text):
# pylint: disable=g-complex-comprehension
return any(
kwd in code
for kwd
in [
'.plot', '.bar(', '.hist(', 'sns.', 'plt.',
'plotly', '.line(', 'iplot(', 'fig.show'
]
)
# pylint: enable=g-complex-comprehension
def get_program_output_variables_spec(
context_code: Text,
code: Text,
output_variables: List[Text] = None
) -> Text:
# Handle the special case of visualizations.
if is_visualization_code(code):
return 'Show a plot.'
ref_exec_state, metadata = get_program_output_state(
context_code,
code,
output_variables
)
if len(ref_exec_state) == 1:
target_output_variable = next(iter(ref_exec_state.values())).value
target_output_type_desc = get_variable_specification(
target_output_variable,
describe_columns=metadata.get('describe_columns', True))
output_spec = f'Return a {target_output_type_desc}.'
elif len(ref_exec_state) > 1:
type_desc_list = []
num_output_variables = len(ref_exec_state)
for _, variable in ref_exec_state.items():
type_desc = get_variable_specification(
variable.value,
describe_columns=metadata.get('describe_columns', True))
type_desc_list.append(type_desc)
is_same_type = len(set(type_desc_list)) == 1
if is_same_type:
output_spec = f'Return {num_output_variables} {type_desc_list[0]}.'
else:
output_spec = f'Return {num_output_variables} variables: '
for type_desc in type_desc_list:
output_spec += f'one {type_desc}' + ', '
output_spec = output_spec.rstrip(', ').rstrip() + '.'
else:
# raise ValueError('Empty ref_exec_state')
output_spec = ''
return output_spec
def get_program_output_variables_spec_wrapper(
turn_example: LmExample,
work_dir: Optional[Text] = None
) -> Text:
tmp_work_dir = os.path.join('/tmp/', str(uuid.uuid4()))
assert not os.path.exists(tmp_work_dir)
if work_dir:
logging.debug('Copying artifacts from %s to %s', work_dir, tmp_work_dir)
shutil.copytree(work_dir, tmp_work_dir)
else:
os.makedirs(tmp_work_dir)
pwd = os.getcwd()
os.chdir(tmp_work_dir)
result = get_program_output_variables_spec(
turn_example.turn.code_context,
turn_example.turn.code.value,
turn_example.turn.intent.output_variables
)
os.chdir(pwd)
return result
def append_output_spec(intent: Text, spec: Text) -> Text:
"""Append output specification to intent text."""
intent = intent.rstrip()
if not any(intent.endswith(x) for x in string.punctuation):
intent += '.'
if not spec.startswith(' '):
spec = ' ' + spec
return intent + spec
def amend_prompt(prompt: Text, text_to_append: Text) -> Text:
prompt = prompt.rstrip().removesuffix('# In[ ]:').rstrip()
if not any(prompt.endswith(x) for x in string.punctuation):
prompt += '.'
delimiter = '\n\n\n# In[ ]:\n\n\n'
prompt = prompt + ' ' + text_to_append.rstrip() + delimiter
return prompt
def infer_program_output_spec_parallel(
dataset: List[Dict[Text, Any]],
**kwargs
) -> Dict[Text, futures.Future[Text]]:
"""Infer output in parallel."""
executor = futures.ProcessPoolExecutor(
max_workers=multiprocessing.cpu_count())
fs = dict()
runtime_artifacts_root = kwargs.pop('runtime_artifacts_root')
for episode_idx, episode in enumerate(dataset):
notebook_name = episode['notebook_name']
turn_example: LmExample
for turn_idx, turn_example in enumerate(episode['turns']):
work_dir = os.path.join(runtime_artifacts_root, episode['work_dir'])
f = executor.submit(
get_program_output_variables_spec_wrapper,
turn_example=turn_example,
work_dir=work_dir,
**kwargs,
)
key = (
f'{notebook_name}_episode{episode_idx}_turn{turn_idx}')
fs[key] = f
return fs
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Build the New Tasks Split (based on Kaggle ML Datasets).
This script downloads the Kaggle ML datasets used and creates
working directories to execute the annotated samples. Data will
be saved at `./dataset/new_tasks/artifacts/`
"""
# pylint: disable=line-too-long
import json
import os
import pathlib
import re
import time
from typing import Optional
import zipfile
from absl import app
import kaggle
import numpy as np
import pandas as pd
import tqdm
from urllib3 import response
Path = pathlib.Path
KAGGLE_DATASET_LIST_PATH = './dataset/new_tasks/kaggle_dataset_provenance.csv'
KAGGLE_DATASET_VERSIONED_PATTERN = r'https://www\.kaggle\.com/datasets/(.*?)/(.*?)/versions/(\d+)\?select=(.*?)$'
KAGGLE_DATASET_PATTERN = r'https://www\.kaggle\.com/datasets/(.*?)/(.*?)\?select=(.*?)$'
def sub_sample_csv(file_path: Path, n: int, seed: int, first: int = 0):
"""Sub-sample n rows from a csv file."""
df = pd.read_csv(file_path)
df_head = df.iloc[:first]
sampled_df = df.iloc[first:].sample(
n=n, random_state=np.random.RandomState(seed)
).sort_index()
if first:
sampled_df = pd.concat([df_head, sampled_df], ignore_index=True)
sampled_df.to_csv(file_path, index=False)
KAGGLE_DATASET_POST_PROCESSORS = {
# Change file names to paths used in the annotated examples.
'surajjha101/myntra-reviews-on-women-dresses-comprehensive': lambda p: os.rename(p / 'Women Dresses Reviews Dataset .csv', p / 'Women Dresses Reviews Dataset.csv'),
'zzettrkalpakbal/full-filled-brain-stroke-dataset': lambda p: os.rename(p / 'full_filled_stroke_data (1).csv', p / 'full_filled_stroke_data.csv'),
# Sub-sample large datasets to speed-up execution.
'ryanjt/baton-rouge-louisiana-traffic-incidents-legacy': lambda p: sub_sample_csv(p / 'Legacy_Baton_Rouge_Traffic_Incidents.csv', n=10000, first=10, seed=401),
'owaiskhan9654/rise-research-innovate-solve-excel': lambda p: sub_sample_csv(p / 'relationship.csv', n=100000, first=10, seed=401),
'ytgangster/online-sales-in-usa': lambda p: sub_sample_csv(p / 'sales.csv', n=50000, first=10, seed=401),
'imoore/age-dataset': lambda p: sub_sample_csv(p / 'AgeDataset-V1.csv', n=100000, first=10, seed=401),
}
def download_kaggle_dataset(
api: kaggle.KaggleApi,
user: str,
dataset_name: str,
target_folder: Path,
dataset_version: Optional[int] = None,
) -> None:
"""Download a Kaggle dataset and extracts contents to the target folder."""
target_folder.mkdir(parents=True, exist_ok=True)
res: response.HTTPResponse = api.datasets_download(
user, dataset_name,
dataset_version_number=dataset_version,
_preload_content=False,
)
file_name = dataset_name + '.zip'
with (target_folder / file_name).open('wb') as f:
f.write(res.data)
res.close()
with zipfile.ZipFile(target_folder / file_name, 'r') as f:
f.extractall(target_folder)
os.remove(target_folder / file_name)
return target_folder
def download_kaggle_dataset_by_url(
url: str,
target_folder: Path,
) -> None:
"""Download a Kaggle dataset file by URL."""
m = re.fullmatch(KAGGLE_DATASET_VERSIONED_PATTERN, url)
if m:
user_name, dataset_name, version, file_name = (
m.group(1), m.group(2), m.group(3), m.group(4))
version = int(version)
else:
m = re.fullmatch(KAGGLE_DATASET_PATTERN, url)
if not m:
raise ValueError(f'Cannot parse URL {url}')
user_name, dataset_name, file_name = (
m.group(1), m.group(2), m.group(3))
version = None
api = kaggle.KaggleApi()
api.authenticate()
del file_name # Not used.
download_kaggle_dataset(
api,
user_name,
dataset_name,
target_folder=target_folder,
dataset_version=version,
)
def download_kaggle_datasets(root: Path) -> None:
"""Download Kaggle datasets used in the New Tasks split."""
root.mkdir(parents=True, exist_ok=True)
api = kaggle.KaggleApi()
api.authenticate()
df = pd.read_csv(KAGGLE_DATASET_LIST_PATH)
for _, entry in tqdm.tqdm(
df.iterrows(),
total=len(df), desc='Downloading Kaggle Datasets'
):
ref = entry['ref']
user, dataset_name = ref.split('/', 1)
version = entry['Version']
not_versioned = False
if version == 'None':
not_versioned = True
version = 1
else:
version = int(version)
dataset_folder = root / dataset_name / 'dataset'
dataset_folder.mkdir(parents=True, exist_ok=True)
try:
download_kaggle_dataset(
api,
user, dataset_name,
dataset_folder,
dataset_version=version,
)
except kaggle.rest.ApiException as e:
res = json.loads(e.body)
# Some datasets do not have version information.
# We first try to download the dataset with version=1.
# If this fails, fall back to download the default dataset.
if res['message'] == 'Not found':
if not_versioned:
print(
f'Cannot find dataset {ref} with version {version}, '
'falling back to download the default version.')
download_kaggle_dataset(api, user, dataset_name, dataset_folder)
else:
raise RuntimeError(
f'Cannot find dataset {ref} with version {version}') from e
else:
raise e
post_processor = KAGGLE_DATASET_POST_PROCESSORS.get(ref)
if post_processor:
post_processor(dataset_folder)
time.sleep(2.5) # Sleep between Kaggle API calls.
def main(_) -> None:
download_kaggle_datasets(Path('./dataset/new_tasks/artifacts/'))
if __name__ == '__main__':
app.run(main)
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utility functions to generate prompts."""
import abc
import copy
import dataclasses
import functools
import re
import string
from typing import Any, Callable, Dict, List, Text, Tuple, Optional, Union
from typing_extensions import Protocol
from ipython_genutils import ipstruct # pylint: disable=g-bad-import-order
import nbformat # pylint: disable=g-bad-import-order
import pandas as pd # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import dataset as dataset_module # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import output_spec_utils # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import schema_utils # pylint: disable=g-bad-import-order
from arcade_nl2code.annotated_dataset import utils # pylint: disable=g-bad-import-order
Cell = ipstruct.Struct
LmExample = dataset_module.LmExample
class IntentPostprocessFn(Protocol):
@abc.abstractmethod
def __call__(
self,
text: Text,
example: dataset_module.LmExample,
*args, **kwargs
) -> Text:
raise NotImplementedError
def all_comments(text: Text) -> bool:
return all(
not line.strip() or line.strip().startswith('#')
for line
in text.split('\n')
)
def cells_to_prompt(
cells_list: List[Text],
remove_empty_cells: bool = False,
cell_marker_style: str = 'nbconvert',
target_cell_type: Optional[str] = 'code'
) -> Text:
"""Convert a list of code/markdown cells to prompt format."""
processed_cells = []
for cell in cells_list:
cell = cell.strip()
if cell or not remove_empty_cells:
if all_comments(cell):
cell_type = 'markdown'
else:
cell_type = 'code'
cell = ipstruct.Struct(cell_type=cell_type, source=cell)
processed_cells.append(cell)
prompt = utils.notebook_to_python(
processed_cells,
cell_marker_style=cell_marker_style,
comment_markdown_cell=False)
# Prompts always end with `\n\n\n# In[ ]:\n`.
if cell_marker_style == 'nbconvert':
assert target_cell_type == 'code'
prompt = prompt.rstrip() + '\n\n\n# In[ ]:\n\n\n'
elif cell_marker_style == 'vscode_custom':
tgt_cell_marker = ''
if target_cell_type == 'code':
tgt_cell_marker = '\n\n# %%[code]\n'
elif target_cell_type == 'markdown':
tgt_cell_marker = '\n\n# %%[markdown]\n'
prompt = prompt.rstrip() + tgt_cell_marker
elif cell_marker_style == 'incoder':
prompt = prompt.rstrip() + '\n<cell>\n'
else:
raise ValueError(cell_marker_style)
return prompt
def concat(prompt_part1: Text, prompt_part2: Text, **kwargs) -> Text:
"""Concatenate two prompt parts."""
cell_marker_style = kwargs.get('cell_marker_style', 'nbconvert')
if cell_marker_style == 'nbconvert':
sep = '\n\n\n'
elif cell_marker_style == 'vscode_custom':
sep = '\n\n'
elif cell_marker_style == 'incoder':
sep = '\n'
else:
raise ValueError(f'Unknown cell_marker_style: {cell_marker_style}')
if cell_marker_style == 'incoder':
if prompt_part2.startswith(utils.INCODER_SOURCE_HEADER):
prompt_part2 = prompt_part2[len(utils.INCODER_SOURCE_HEADER):].lstrip()
return prompt_part1.rstrip() + sep + prompt_part2.lstrip()
@dataclasses.dataclass
class Exemplar:
"""An NL to Code exemplar for in-context few-shot learning."""
intent: Text
# Mapping from solution type to the solution in code.
solutions: Dict[Text, Text] = dataclasses.field(default_factory=dict)
df_init_code: Optional[Text] = None
df: Optional[pd.DataFrame] = None
df_name: Optional[Text] = None
dataset_name: Optional[Text] = None
def get_decomposed_solution_no_step_prefix(
code: Text
) -> Text:
"""Get step-by-step code solution without step prefix index."""
lines = code.split('\n')
processed_lines = []
for line in lines:
if line.strip().startswith('# Step'):
line = re.sub(r' *# Step \d+: *', '# ', line)
line = '# ' + re.sub(r'# Step \d+:', '', line).lstrip()
processed_lines.append(line)
return '\n'.join(processed_lines)
def parse_exemplars(
template_notebook: nbformat.NotebookNode,
exemplar_type: Optional[Text] = None,
exemplar_indices: Optional[List[int]] = None,
return_structured_data: bool = False,
) -> Union[
List[Exemplar],
Tuple[List[Cell], List[Exemplar]]
]:
"""Parse exemplars defined in the given template notebook."""
if not return_structured_data and not exemplar_type:
raise ValueError('Must specify exemplar_type')
if exemplar_type and exemplar_type.startswith('code_only'):
exemplar_type = 'code_only'
cells = []
examples = []
cell_ptr = 0
example_idx = 0
while cell_ptr < len(template_notebook.cells):
cell = template_notebook.cells[cell_ptr]
if cell.cell_type == 'markdown' and cell.source.startswith('# Exercise'):
df_init_cell = template_notebook.cells[cell_ptr + 1]
assert df_init_cell.source.startswith('# Data Defination'), df_init_cell
df_init_cell.custom_cell_type = 'data_defination'
datafile_name = re.search(
r'\((.+)\)',
df_init_cell.source.split('\n')[0]
).group(1)
exec_globals = {}
source_to_exec = f"""
import pandas as pd
{df_init_cell.source}
"""
# Execute solutions for exemplars in the template notebook.
exec(source_to_exec, exec_globals) # pylint: disable=exec-used
assert (
'df' in exec_globals and
isinstance(exec_globals['df'], pd.DataFrame))
# Get context code cells before the intent cell appears.
context_code_cells = []
cell_ptr += 2
while (
cell_ptr < len(template_notebook.cells) and
template_notebook.cells[cell_ptr].cell_type == 'code'
):
context_cell = template_notebook.cells[cell_ptr]
context_cell.custom_cell_type = 'context'
context_code_cells.append(context_cell)
cell_ptr += 1
intent_cell = template_notebook.cells[cell_ptr]
assert intent_cell.cell_type == 'markdown'
assert intent_cell.source.startswith('Task:')
intent_cell.custom_cell_type = 'intent'
cell_ptr += 1
exemplar = Exemplar(
df_init_code=df_init_cell.source,
df_name='df',
df=exec_globals['df'],
dataset_name=datafile_name,
intent=intent_cell.source.partition('Task:')[-1].strip()
)
while (
cell_ptr < len(template_notebook.cells) and
template_notebook.cells[cell_ptr].cell_type == 'code'
):
cell = template_notebook.cells[cell_ptr]
source = cell.source.strip()
assert source.startswith('### Type:')
first_line = source[:source.find('\n')]
solution_type = first_line.partition(':')[-1].strip()
assert solution_type
solution_code = '\n'.join(source.split('\n')[1:]).strip()
exemplar.solutions[solution_type] = solution_code
if (
solution_type == 'step'
):
# Add code-only solutions.
exemplar.solutions['code_only'] = utils.remove_comments(solution_code)
decomposed_solution_no_step_prefix = (
get_decomposed_solution_no_step_prefix(solution_code))
exemplar.solutions['step_no_prefix'] = (
decomposed_solution_no_step_prefix)
cell_ptr += 1
assert exemplar.solutions
code = exemplar.solutions.get(exemplar_type, 'raise NotImplementedError')
exemplar_cells = [
Cell(
cell_type='markdown',
custom_cell_type='example_header',
source='# Exercise {exemplar_id}'
),
df_init_cell,
*context_code_cells,
intent_cell,
Cell(
cell_type='code',
custom_cell_type='solution',
source=code
)
]
exemplar.idx = example_idx
exemplar.cells = exemplar_cells
examples.append(exemplar)
example_idx += 1
else:
# It's a cell for boilerplate stuff.
if not cell.source.startswith('# Metadata'):
cell.custom_cell_type = 'boilerplate'
cells.append(cell)
cell_ptr += 1
cells = copy.deepcopy(cells)
exemplar_indices = exemplar_indices or list(range(len(examples)))
for abs_idx, idx in enumerate(exemplar_indices, start=1):
exemplar_cells = copy.deepcopy(examples[idx].cells)
exemplar_cells[0].source = exemplar_cells[0].source.format(
exemplar_id=abs_idx)
cells.extend(exemplar_cells)
examples = [examples[idx] for idx in exemplar_indices]
if return_structured_data:
return examples
else:
return cells, examples
def get_exemplars_part_in_prompt(
template_notebook: nbformat.NotebookNode,
exemplar_type: Text,
exemplar_indices: Optional[List[int]] = None,
intent_postprocess_fn: Optional[IntentPostprocessFn] = None,
response_postprocess_fn: Optional[Callable[[Text], Text]] = None,
append_output_spec: bool = False,
schema_representation_config:
Optional[schema_utils.SchemaRepresentationConfig] = None,
variable_verbalizer_kwargs: Optional[Dict[Text, Any]] = None,
textify_func_kwargs: Optional[Dict[Text, Any]] = None
) -> Text:
"""Generate the prompt text for selected few-shot examples."""
textify_func_kwargs = textify_func_kwargs or {}
exemplars_cells, exemplars = parse_exemplars(
template_notebook, exemplar_type, exemplar_indices)
cells = []
# Meta information before the solution for an exemplar.
exemplar_context_cells = intent_cell_idx = None
for _, cell in enumerate(exemplars_cells, start=1):
additional_cells = []
if cell.cell_type == 'code':
if cell.source.startswith('# Data Defination'):
df_init_code = cell.source
assert exemplar_context_cells is None
exemplar_context_cells = [
'import pandas as pd',
df_init_code,
]
df_init_metadata_line = df_init_code[:df_init_code.find('\n')]
datafile_name = re.search(r'\((.+)\)', df_init_metadata_line).group(1)
df_cell_source = f"df = pd.read_csv('{datafile_name}')"
if schema_representation_config:
schema_info = schema_utils.extract_schema_information_from_code(
exemplar_context_cells,
target_dataframes=['df'],
schema_representation_config=schema_representation_config,
verbalizer_kwargs=variable_verbalizer_kwargs
)
cell_schema_info = schema_info[0]
# Change offset to account for the first synthetic line.
cell_schema_info['cell_idx'] = 0
# Change line num to account for header metadata.
cell_schema_info['df_variables'][0].line_num = 0
modified_cells = schema_utils.insert_schema_representations_to_cells(
[df_cell_source],
schema_info=schema_info,
schema_representation_config=schema_representation_config
)
cell.source = modified_cells[0]
# Append any additional cells generated for variable state annotation.
if len(modified_cells) > 1:
for new_cell_source in modified_cells[1:]:
new_cell = Cell(cell_type='code', source=new_cell_source)
additional_cells.append(new_cell)
else:
cell.source = df_cell_source
elif cell.custom_cell_type == 'solution':
# If this is a solution cell.
if response_postprocess_fn:
cell.source = response_postprocess_fn(cell.source)
# Post-process the intent cell above with any information
# from the solution.
assert isinstance(intent_cell_idx, int)
intent_cell = cells[intent_cell_idx] # pylint: disable=invalid-sequence-index
intent = intent_cell.source
if append_output_spec:
assert exemplar_context_cells
output_spec = output_spec_utils.get_program_output_variables_spec(
'\n'.join(exemplar_context_cells),
cell.source
)
intent = output_spec_utils.append_output_spec(intent, output_spec)
if intent_postprocess_fn:
intent = intent_postprocess_fn(intent, example=None)
intent_cell.source = intent
# Reset for the next exemplar.
exemplar_context_cells = None
intent_cell_idx = None
elif (
cell.cell_type == 'markdown' and
cell.source.strip().startswith('Task:')
):
intent_cell_source = cell.source.partition('Task:')[-1].strip()
assert intent_cell_idx is None
intent_cell_idx = len(cells)
# Intent cell is further modified when parsing the solution cell.
cell.source = intent_cell_source
cells.append(cell)
cells.extend(additional_cells)
cells.append(
Cell(cell_type='markdown', source=f'# Exercise {len(exemplars) + 1}'))
exemplar_text = utils.notebook_to_python(
cells,
**textify_func_kwargs,
comment_markdown_cell=(
textify_func_kwargs.get('cell_marker_style') != 'incoder')
)
return exemplar_text
def prepend_and_append_text(
text: Text,
example: LmExample,
prefix: Text = 'Task: ',
suffix: Text = ' Explain your solution.',
normalize: bool = True
) -> Text:
"""Append and prepend texts to NL intents."""
del example # Not used.
if text and text[-1] not in string.punctuation:
text += '.'
if normalize:
text = utils.markdown_to_text(text)
text = prefix + text.strip() + suffix
return text
FORMAT_CONFIG_WITH_PREFIX_KEYWORD = {
'intent_postprocess_fn':
functools.partial(
prepend_and_append_text,
prefix='Problem: ',
suffix='',
),
'response_postprocess_fn':
lambda x: '# Solution:\n' + x,
'prompt_postprocess_fn':
lambda x, _: x + '# Solution:\n'
}
FORMAT_CONFIG_WITH_PREAMBLE = {
**FORMAT_CONFIG_WITH_PREFIX_KEYWORD,
'response_postprocess_fn':
lambda x: '# Solution: Let\'s solve this problem step-by-step.\n' + x,
'prompt_postprocess_fn':
lambda x, _: x + '# Solution: Let\'s solve this problem step-by-step.\n'
}
EXEMPLAR_FORMAT_CONFIGS = {
'short_code_no_preamble': {
'exemplar_type': 'short',
**FORMAT_CONFIG_WITH_PREFIX_KEYWORD
},
'step+explanation': {
'exemplar_type': 'step',
**FORMAT_CONFIG_WITH_PREAMBLE
},
'step_only': {
'exemplar_type': 'code_only',
**FORMAT_CONFIG_WITH_PREAMBLE
},
'step_only_no_preamble': {
'exemplar_type': 'code_only',
**FORMAT_CONFIG_WITH_PREFIX_KEYWORD
},
}
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Exeucting code snippets that depdent on programmatic contexts."""
import contextlib
import copy
import dataclasses
import io
import logging
import multiprocessing
import multiprocessing.connection
import time
import types
from typing import Any, Dict, Optional, Text
# TODO(pcyin): Check which one is better at serialization: dill or cloudpickle.
import cloudpickle as plk
UNCOPYABLE_OBJ_STRING = '<UNCOPYABLE_OBJ>'
@dataclasses.dataclass
class ExecutionState:
"""A dict of the names and values of variables.
Store variables that are newly created or changed w.r.t. the previous
programmatic context after running the traced code.
"""
exec_globals: Optional[Dict[Text, Any]] = None
error: bool = False
error_text: Optional[Text] = None
def copy(self) -> 'ExecutionState':
return ExecutionState(
exec_globals=(
copy_variable_dict(self.exec_globals)
if self.exec_globals is not None
else None),
error=self.error,
error_text=self.error_text
)
class DummyIOSink(io.StringIO):
"""Consume the outputs of executed code so they won't show up on stdout."""
def exec_wrapper(
source_code: Text,
exec_globals: Dict[Text, Any],
suppress_logging: bool = True
) -> ExecutionState:
"""Wrapper of `exec()` with error handling."""
# TODO(pcyin): Add wrapper to remove risky functions in standard library.
dummy_io = DummyIOSink()
with contextlib.redirect_stdout(dummy_io):
with contextlib.redirect_stderr(dummy_io):
if suppress_logging:
logging.disable(logging.CRITICAL)
try:
exec(source_code, exec_globals) # pylint: disable=exec-used
except Exception as e: # pylint: disable=broad-except
state = ExecutionState(
None,
error=True, error_text=e.__class__.__name__ + ': ' + str(e))
else:
state = ExecutionState(exec_globals)
if suppress_logging:
logging.disable(logging.NOTSET)
return state
def copy_variable_dict(
variable_dict: Dict[Text, Any],
copy_module: bool = False
) -> Dict[Text, Any]:
"""Deep copy a dict that stores variables states.
This function is adapted from the same function in
`program_synthesis.abcm.meena.execution_tracing.tracing`.
Args:
variable_dict: A dict of variable names and their values.
copy_module: Whether to copy modules as well.
Returns:
A deep copy of `variable_dict`.
"""
new_values_dict = dict()
for var_name, var_value in variable_dict.items():
if var_name == '__builtins__':
continue
elif isinstance(var_value, types.ModuleType):
if copy_module:
new_values_dict[var_name] = plk.loads(plk.dumps(var_value))
else:
# Modules shallow copies.
new_values_dict[var_name] = var_value
else:
try:
new_values_dict[var_name] = copy.deepcopy(var_value)
except TypeError:
new_values_dict[var_name] = UNCOPYABLE_OBJ_STRING
except Exception: # pylint: disable=broad-except
new_values_dict[var_name] = UNCOPYABLE_OBJ_STRING
return new_values_dict
def async_trace_wrapper_fn(
source_code: Text,
exec_globals: Dict[Text, Any],
suppress_logging: bool = True,
use_tracing: bool = True,
return_value_pipe: Optional[multiprocessing.connection.Connection] = None
):
"""Wrapper function for running tracing in a process."""
time_start = time.time()
if use_tracing:
raise NotImplementedError()
else:
exec_wrapper(source_code, exec_globals, suppress_logging)
exec_globals_after = exec_globals
logging.debug(
'[Worker] %.2fs took to trace code', time.time() - time_start)
if return_value_pipe is not None:
time_start = time.time()
logging.debug('[Worker] begin pickling trace result')
serialized_trace_result = plk.dumps(exec_globals_after)
logging.debug('[Worker] %.2fs took to pickle trace result (size=%d bytes)',
time.time() - time_start, len(serialized_trace_result))
return_value_pipe.send(serialized_trace_result)
logging.debug('[Worker] trace result sent; worker terminated')
def execute_code(
source_code: Text,
exec_globals: Optional[Dict[Text, Any]] = None,
use_tracing: bool = False,
timeout: int = -1,
copy_state: bool = True,
close_figures: bool = False,
suppress_logging: bool = True
) -> ExecutionState:
"""Trace the execution of a code snippet given global execution contexts."""
exec_globals = exec_globals or {}
if copy_state:
exec_globals = copy_variable_dict(exec_globals)
if close_figures:
source_code = 'import matplotlib.pyplot as __plt__\n__plt__.close("all")\n' + source_code
time_start = time.time()
if timeout > 0:
p = multiprocessing.Process(
target=async_trace_wrapper_fn,
args=(source_code, exec_globals, suppress_logging, use_tracing, None),
daemon=True)
p.start()
p.join(timeout)
if p.is_alive():
p.kill()
raise TimeoutError()
logging.debug(('Executing code:\n'
'*****************************\n'
'%s\n'
'*****************************'),
source_code)
logging.debug('exec_globals: %s', list(exec_globals))
if use_tracing:
assert copy_state
# Run tracing in the current process.
# TODO(pcyin): Implement tracing.
raise NotImplementedError()
else:
exec_state = exec_wrapper(source_code, exec_globals, suppress_logging)
logging.debug('%.2fs took to execute code', time.time() - time_start)
return exec_state
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for processors."""
import textwrap
from absl.testing import absltest
from arcade_nl2code.evaluation import processors
DUMMY_PREDICTION = textwrap.dedent("""
# In[ ]:
# Inline comment.
foo.bar()
# Another inline comment.
def my_func():
pass
# In[ ]:
# This cell is a markdown cell
# without any code.
# In[ ]:
# Here is another code cell with one comment.
foo.bar()
""")
DUMMY_PREDICTION_CODE_IN_SECOND_CELL = textwrap.dedent("""
# In[ ]:
# This cell is a markdown cell
# without any code.
# In[ ]:
# Inline comment.
foo.bar()
# Another inline comment.
def my_func():
pass
# In[ ]:
# Here is another code cell with one comment.
foo.bar()
""")
DUMMY_PREDICTION_WITH_COMMENT_PREFIX_PROMPT = textwrap.dedent("""
Use value_count() to get frequency.
df.value_count()
# In[ ]:
# Here is another code cell with one comment.
foo.bar()
""").lstrip()
DUMMY_PREDICTION_WITH_COMMENT_PREFIX_PROMPT_SECOND_CELL = textwrap.dedent("""
First line of markdown cell.
# This cell is a markdown cell
# without any code.
# In[ ]:
# Use value_count() to get frequency.
df.value_count()
# In[ ]:
# Here is another code cell with one comment.
foo.bar()
""").lstrip()
class ProcessorsTest(absltest.TestCase):
def test_extract_first_cell_block_remove_comment(self):
extracted_code = processors.extract_first_cell_block(
DUMMY_PREDICTION, remove_comment=True)
expected_code = textwrap.dedent("""
foo.bar()
def my_func():
pass
""").strip()
self.assertEqual(extracted_code, expected_code)
def test_extract_first_cell_block_not_remove_comment(self):
extracted_code = processors.extract_first_cell_block(
DUMMY_PREDICTION, remove_comment=False)
expected_code = textwrap.dedent("""
# Inline comment.
foo.bar()
# Another inline comment.
def my_func():
pass
""").strip()
self.assertEqual(extracted_code, expected_code)
def test_extract_first_cell_block_code_in_second_cell(self):
extracted_code = processors.extract_first_cell_block(
DUMMY_PREDICTION_CODE_IN_SECOND_CELL, remove_comment=False)
expected_code = textwrap.dedent("""
# Inline comment.
foo.bar()
# Another inline comment.
def my_func():
pass
""").strip()
self.assertEqual(extracted_code, expected_code)
def test_extract_code_from_prompt_with_comment_prefix(self):
extracted_code = processors.extract_code_from_prompt_with_comment_prefix(
DUMMY_PREDICTION_WITH_COMMENT_PREFIX_PROMPT, prefix='# Solution: ')
expected_code = textwrap.dedent("""
# Solution: Use value_count() to get frequency.
df.value_count()
""").strip()
self.assertEqual(extracted_code, expected_code)
def test_extract_code_from_prompt_with_comment_prefix_code_second_cell(self):
extracted_code = processors.extract_code_from_prompt_with_comment_prefix(
DUMMY_PREDICTION_WITH_COMMENT_PREFIX_PROMPT_SECOND_CELL,
prefix='# Solution: ')
expected_code = textwrap.dedent("""
# Solution: First line of markdown cell.
# This cell is a markdown cell
# without any code.
# In[ ]:
# Use value_count() to get frequency.
df.value_count()
""").strip()
self.assertEqual(extracted_code, expected_code)
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Main script to compute functional-correctness for annotated notebook data.
"""
import contextlib
import copy
import distutils.dir_util # pylint: disable=deprecated-module
import functools
import gc
import json
import multiprocessing
import os
import pathlib
import queue
import random
import sys
import tempfile
import time
from typing import Any, Dict, List, Optional, Sequence, Text, Tuple
from absl import app
from absl import flags
from absl import logging
from tensorflow.io import gfile
# pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import dataset
from arcade_nl2code.evaluation import execution_evaluation
from arcade_nl2code.evaluation import processors
from arcade_nl2code.evaluation import utils
# Disable logging of some modules.
# logging.getLogger('matplotlib').setLevel(logging.WARNING)
EpisodePrediction = dataset.EpisodePrediction
_INPUT_FLAG = flags.DEFINE_string(
'prediction_file', None,
'Path to model predictions.', required=True)
_ARTIFACT_ROOT_FLAG = flags.DEFINE_string(
'runtime_artifact_root', None,
'Path to the evaluation notebooks that contain artifacts like datasets',
required=True)
_OUTPUT_FLAG = flags.DEFINE_string(
'output_path', None, 'Path to evaluation result.', required=True)
_TIMEOUT_FLAG = flags.DEFINE_integer(
'timeout', -1, 'Timeout after N seconds of execution')
_WORKER_NUM_FLAG = flags.DEFINE_integer(
'num_workers', 1,
'Number of workers for parallel tracing and evaluation in each work unit.')
_NUM_WORK_UNITS_FLAG = flags.DEFINE_integer(
'num_work_units', 1, 'Number of total parallel work units.')
_WORK_UNIT_ID_FLAG = flags.DEFINE_integer(
'work_unit_id', 0, 'Id of this work unit.')
_EPISODE_TIMEOUT_FLAG = flags.DEFINE_integer(
'episode_timeout', 3600 * 5, 'Timeout for evaluating a single episode.')
_TOPK_FLAG = flags.DEFINE_integer(
'topk', -1, 'Top K predictions to evaluate.')
_FIRST_N_EXAMPLES_FLAG = flags.DEFINE_integer(
'first', -1, 'First N examples to evaluate.')
_USE_TEMP_WORK_DIR_FLAG = flags.DEFINE_bool(
'use_temp_work_dir', True, 'Use temperory working directory')
_REUSE_STATE_FLAG = flags.DEFINE_bool(
'reuse_state', True, 'Reuse variable states of shared contexts')
_SPLIT_EPISODE_FLAG = flags.DEFINE_bool(
'split_episode', False, 'Split episode for maximum level of parallelism')
_SHUFFLE_FLAG = flags.DEFINE_bool(
'shuffle', False,
'Shuffle examples. This will randomly dispatch examples in the same '
'episode across different work units. This could improve parallelism '
'when executing long-running examples from the same episode.')
_OUTPUT_EVALUATED_PREDICTION_FLAG = flags.DEFINE_bool(
'save_evaluated_predictions', True,
'Whether to output the prediction file with evaluation details as well.')
_OUTPUT_PROCESSOR_FLAG = flags.DEFINE_enum(
'lm_output_postprocessor',
'extract_first_cell_block',
[
'extract_first_cell_block',
'extract_code_from_prompt_with_comment_prefix',
'extract_code_from_prompt_with_comment_prefix_vscode_style',
'extract_code_from_prompt_incoder',
'pass_through',
],
'Function to extract prediction from LM\'s output (which runs till EOS)')
_OUTPUT_PROCESSOR_KWARGS_FLAG = flags.DEFINE_string(
'lm_output_postprocessor_kwargs',
'',
'Json-encoded extra kwargs passed to the processor.'
)
_SELF_CONSISTENCY_DECODING_FLAG = flags.DEFINE_bool(
'self_consistency_decoding', False,
'Whether to perform self-consistency decoding by majority vote.')
_STATE_COMPARISON_FUNCTION_FLAG = flags.DEFINE_enum(
'state_comparison_function',
'fuzzy_match',
['fuzzy_match', 'strict_match'],
'Mode for comparing the execution results of reference and hypothesis '
'code. `fuzzy_match` allows some superficial discrepancies between like '
'column orders in pandas dataframes. `strict_match` denotes exact match.',
)
_SELF_CONSISTENCY_COMPARISON_FUNCTION_FLAG = flags.DEFINE_enum(
'self_consistency_comparison_function',
'fuzzy_match',
['fuzzy_match', 'strict_match'],
'Function to use to compare two clusters of outputs.',
)
_CONTEXT_USE_PRIOR_PREDICTION_FLAG = flags.DEFINE_bool(
'context_use_prior_prediction', False,
'Whether to use predicted code from prior turns as context for '
'the current turn')
_LOG_METRICS_FLAG = flags.DEFINE_bool(
'log_metrics', True, 'Whether to log metrics.')
def get_payload_slice(
worker_idx: int, num_workers: int, payload_size: int) -> Tuple[int, int]:
"""Slices the dataset and assign workload for each process."""
if payload_size < num_workers:
payload_size = num_workers
load_size_per_worker = payload_size // num_workers
start = load_size_per_worker * worker_idx
end = start + load_size_per_worker
if payload_size % num_workers > 0 and worker_idx == num_workers - 1:
end = payload_size
return start, end
def get_example_execution_dir(
episode_prediction: Dict[str, Any],
runtime_artifact_root: Optional[str] = None
) -> str:
"""Get the folder path that contains dataset files used by the episode."""
work_dir = episode_prediction['metadata'].get('work_dir', None) # pytype: disable=attribute-error
if not work_dir:
assert runtime_artifact_root
work_dir = runtime_artifact_root
elif runtime_artifact_root:
work_dir = pathlib.Path(runtime_artifact_root) / work_dir
work_dir = str(work_dir)
if not (gfile.isdir(work_dir) and gfile.exists(work_dir)):
logging.warning(
'Working directory not found: %s, setting to empty',
work_dir
)
work_dir = ''
return work_dir
def eval_fn(
workload: Any,
runtime_artifact_root: str,
evaluator_config: Dict[Text, Any],
use_temp_work_dir: bool = True,
return_pipe: multiprocessing.Pipe = None
) -> ...:
"""Wrapper of the valuation function."""
return_value = ([], [], [])
for episode_prediction in workload:
work_dir = get_example_execution_dir(
episode_prediction,
runtime_artifact_root,
)
if use_temp_work_dir:
context_manager_fn = tempfile.TemporaryDirectory
else:
context_manager_fn = lambda: contextlib.nullcontext(work_dir) # pylint: disable=cell-var-from-loop
with context_manager_fn() as tmp_work_dir:
assert os.path.exists(tmp_work_dir)
if work_dir and not os.path.samefile(tmp_work_dir, work_dir):
logging.debug(
'Copying artifacts from %s to %s', work_dir, tmp_work_dir)
distutils.dir_util.copy_tree(work_dir, tmp_work_dir)
evaluator = execution_evaluation.NotebookEvaluator(tmp_work_dir)
metrics, metadata = evaluator.evaluate_episode(
episode_prediction,
timeout=evaluator_config['timeout'],
self_consistency_decoding=evaluator_config[
'self_consistency_decoding'],
self_consistency_comparison_function=evaluator_config[
'self_consistency_comparison_function'],
state_comparison_function=evaluator_config[
'state_comparison_function'],
context_use_prior_prediction=evaluator_config[
'context_use_prior_prediction'],
top_k=evaluator_config['top_k'],
reuse_state=evaluator_config['reuse_state'],
log_metrics=evaluator_config['log_metrics'],
)
return_value[0].append(metrics)
return_value[1].append(metadata)
return_value[2].append(episode_prediction)
if return_pipe:
return_pipe.send(return_value)
return_pipe.close()
else:
return return_value
class WorkerProcess(multiprocessing.Process):
"""Worker process that runs evaluation."""
def __init__(
self,
runtime_artifact_root: Text,
job_queue: multiprocessing.Queue,
result_queue: multiprocessing.Queue,
finished: multiprocessing.Event,
evaluator_config: Dict[Text, Any],
child_process_timeout_secs: int,
use_child_process: bool = True,
use_temp_work_dir: bool = True,
**kwargs
):
super(WorkerProcess, self).__init__(**kwargs)
self.runtime_artifact_root = runtime_artifact_root
self.use_child_process = use_child_process
self.child_process_timeout_secs = child_process_timeout_secs
self.evaluator_config = evaluator_config
self.use_temp_work_dir = use_temp_work_dir
self.job_queue = job_queue
self.result_queue = result_queue
self.finished = finished
def run(self):
while not self.finished.is_set():
try:
payload = self.job_queue.get(timeout=1)
idx, prediction = payload
if self.use_child_process:
# Use spawn to avoid potential deadlocking.
mp_context = multiprocessing.get_context('spawn')
# Sometimes the subprocess crashes for random reasons and
# `recv_end.poll` raises EOFError. We retry execution when
# EOFError.
max_num_trial = 1
num_trial = 0
success = False
while not success and num_trial < max_num_trial:
recv_end, send_end = mp_context.Pipe(duplex=False)
execution_proc = mp_context.Process(
target=eval_fn,
args=([prediction],
self.runtime_artifact_root,
self.evaluator_config,
self.use_temp_work_dir,
send_end))
episode_name = prediction['metadata']['notebook_name']
execution_proc.start()
send_end.close()
error_message = None
try:
if recv_end.poll(timeout=self.child_process_timeout_secs):
result = recv_end.recv()
else:
error_message = (
'Execution process for episode '
f'[{episode_name}] timed out.')
logging.error(error_message)
result = None
recv_end.close()
success = True # Timeout is still considerred OK.
except EOFError:
error_message = (
'Execution process for episode '
f'[{episode_name}] crashed with EOF error. Retrying...')
logging.error(error_message)
result = None
recv_end.close()
except Exception as e:
raise RuntimeError(
f'[Fatal] Execution process for episode [{episode_name}] '
'crashed for unknown reason. Raising exception from its '
'worker process.'
) from e
num_trial += 1
gc.collect()
if not success:
logging.error(
'Execution process for episode [%s] failed after %d trials.',
episode_name, num_trial)
execution_proc.join(60)
if execution_proc.exitcode != 0 or execution_proc.is_alive():
logging.error(
'Execution Process Error: still alive: %s, exitcode: %s',
execution_proc.is_alive(),
execution_proc.exitcode)
if execution_proc.is_alive():
execution_proc.kill()
# Create dummy metrics and metadata.
dummy_metadata = dict(
html_report=(
'<h3 style="color:red">Execution process crashed.</h3>\n'
f'<p>{error_message}</p>\n'
)
)
for turn in prediction['turns']:
turn['is_valid_example'] = False
turn['error_text'] = 'Execution process crashed.'
eval_result = (execution_evaluation
.EXECUTION_ERROR_EVAL_MARKER.copy())
eval_result['error_text'] = turn['error_text']
turn['eval_results'] = [eval_result]
dummy_metrics = [
turn['eval_results'] for turn in prediction['turns']]
result = [[dummy_metrics], [dummy_metadata], [prediction]]
else:
assert result is not None
else:
result = eval_fn(
[prediction],
self.runtime_artifact_root,
self.evaluator_config,
self.use_temp_work_dir)
self.result_queue.put((idx, result))
except queue.Empty:
pass
def get_work_unit_input_slice(
predictions: List[EpisodePrediction],
work_unit_id: int,
num_work_units: int,
) -> List[EpisodePrediction]:
"""Get the slice of predictions to evaluate for the given work unit ID."""
num_examples = len(predictions)
batch_size = num_examples // num_work_units
indices = list(range(num_examples))
if _SHUFFLE_FLAG.value:
random.seed(1234)
random.shuffle(indices)
if work_unit_id < num_work_units - 1:
workload_slice_indices = indices[
batch_size * work_unit_id:
batch_size * (work_unit_id + 1)
]
else:
workload_slice_indices = indices[batch_size * work_unit_id:]
workload_slice = [predictions[i] for i in workload_slice_indices]
return workload_slice
def get_shard_result_file_name(
work_unit_id: int,
num_work_units: int,
) -> Text:
return f'results.json.shard-{work_unit_id}-of-{num_work_units}'
def split_episodes(
episode_predictions: List[EpisodePrediction],
split_hyps: bool = False
) -> ...:
"""Split turns into individual episodes for better parallization."""
pseudo_episodes = []
for episode_idx, episode_prediction in enumerate(episode_predictions):
for turn_idx, turn_prediction in enumerate(episode_prediction['turns']):
other_metadata = { # pylint: disable=g-complex-comprehension
key: value
for key, value
in turn_prediction['metadata'].items()
if key != 'example'
}
if split_hyps:
for hyp_idx, hyp in enumerate(turn_prediction['predictions']):
hyp_example: dataset.LmExample = copy.deepcopy(
turn_prediction['metadata']['example'])
hyp_example.turn.delta_code_context = hyp_example.turn.code_context
hyp_entry = dict(
metadata={
**episode_prediction['metadata'],
'notebook_name': (
f'{episode_prediction["metadata"]["notebook_name"]}'
f'|||turn_{turn_idx}|||hyp_{hyp_idx}'),
'__episode_idx': episode_idx,
'__turn_idx': turn_idx,
'__hyp_idx': hyp_idx
},
turns=[dict(
predictions=[hyp],
metadata=dict(
example=hyp_example,
**other_metadata
)
)]
)
pseudo_episodes.append(hyp_entry)
else:
turn_example: dataset.LmExample = copy.deepcopy(
turn_prediction['metadata']['example'])
turn_entry = dict(
metadata={
**episode_prediction['metadata'],
'notebook_name': (
f'{episode_prediction["metadata"]["notebook_name"]}'
f'|||turn_{turn_idx}'),
'__episode_idx': episode_idx,
'__turn_idx': turn_idx,
'__hyp_idx': list(range(len(turn_prediction['predictions']))),
},
turns=[dict(
predictions=turn_prediction['predictions'],
metadata=dict(
example=turn_example,
**other_metadata
)
)]
)
if _CONTEXT_USE_PRIOR_PREDICTION_FLAG.value:
turn_predictions_context_code = []
for hyp_idx in range(len(turn_prediction['predictions'])):
hyp_context_code = execution_evaluation.get_context_code(
turn_example.turn,
turn_idx=turn_idx,
prediction_idx=hyp_idx,
episode_prediction=episode_prediction,
context_use_prior_prediction=True,
)
turn_predictions_context_code.append(hyp_context_code)
turn_entry['metadata']['__hyp_context_code'] = (
turn_predictions_context_code)
pseudo_episodes.append(turn_entry)
return pseudo_episodes
def merge_split_episodes(
predictions: List[EpisodePrediction],
original_episode_predictions: List[EpisodePrediction]
) -> Tuple[
List[EpisodePrediction],
List[List[List[Dict[Text, Any]]]]
]:
"""Merge the split episodes.
Args:
predictions: List of split predictions for the current work unit.
original_episode_predictions: Original un-split predictions for the whole
dataset.
Returns:
Aggregated predictions, which can be a sub-set of the original predictions
if there are multiple work units.
"""
for entry in predictions:
episode_idx = entry['metadata']['__episode_idx']
turn_idx = entry['metadata']['__turn_idx']
hyp_idx = entry['metadata']['__hyp_idx']
original_episode_prediction = original_episode_predictions[episode_idx]
turn_prediction = original_episode_prediction['turns'][turn_idx]
assert len(entry['turns']) == 1
turn_result = entry['turns'][0]
turn_prediction.setdefault(
'is_valid_example', turn_result['is_valid_example'])
if 'error_text' in turn_result:
turn_prediction.setdefault(
'error_text', turn_result['error_text'])
if 'hyp_clusters' in turn_result:
turn_prediction.setdefault(
'hyp_clusters', turn_result['hyp_clusters'])
if 'ref_output_html' in turn_result:
turn_prediction.setdefault(
'ref_output_html', turn_result['ref_output_html'])
if isinstance(hyp_idx, int):
assert len(turn_result['eval_results']) == 1
turn_prediction.setdefault('eval_results', []).append(
(hyp_idx, turn_result['eval_results'][0]))
else:
assert isinstance(hyp_idx, list)
hyp_idx_list = hyp_idx
if turn_result['is_valid_example']:
assert len(turn_result['eval_results']) == len(hyp_idx_list)
turn_prediction.setdefault('eval_results', []).extend(
list(zip(hyp_idx_list, turn_result['eval_results'])))
else:
assert len(turn_result['eval_results']) == 1
turn_prediction['eval_results'] = [(0, turn_result['eval_results'][0])]
for original_episode_prediction in original_episode_predictions:
for turn in original_episode_prediction['turns']:
turn['eval_results'] = list(map(
lambda x: x[1],
sorted(turn['eval_results'], key=lambda x: x[0])
))
episode_eval_results = []
for original_episode_prediction in original_episode_predictions:
episode_eval_results.append([])
for turn_prediction in original_episode_prediction['turns']:
episode_eval_results[-1].append(turn_prediction['eval_results'])
return original_episode_predictions, episode_eval_results
def parse_evaluator_config() -> Dict[Text, Any]:
"""Parse evaluator config from flags."""
config = dict(
timeout=_TIMEOUT_FLAG.value,
self_consistency_decoding=_SELF_CONSISTENCY_DECODING_FLAG.value,
state_comparison_function=_STATE_COMPARISON_FUNCTION_FLAG.value,
self_consistency_comparison_function=(
_SELF_CONSISTENCY_COMPARISON_FUNCTION_FLAG.value),
context_use_prior_prediction=_CONTEXT_USE_PRIOR_PREDICTION_FLAG.value,
top_k=_TOPK_FLAG.value,
reuse_state=_REUSE_STATE_FLAG.value,
log_metrics=_LOG_METRICS_FLAG.value,
)
return config
def evaluate_main():
"""Main evaluation function."""
lm_output_postprocessor_fn = {
'extract_first_cell_block':
processors.extract_first_cell_block,
'extract_code_from_prompt_with_comment_prefix': (
processors.extract_code_from_prompt_with_comment_prefix),
'extract_code_from_prompt_with_comment_prefix_vscode_style': (
processors.extract_code_from_prompt_with_comment_prefix_vscode_style
),
'extract_code_from_prompt_incoder': (
processors.extract_code_from_prompt_incoder),
'pass_through': None,
}.get(_OUTPUT_PROCESSOR_FLAG.value, None)
if _OUTPUT_PROCESSOR_KWARGS_FLAG.value:
processor_kwargs = json.loads(_OUTPUT_PROCESSOR_KWARGS_FLAG.value)
logging.info('LM output postprocessor using kwargs: %s', processor_kwargs)
lm_output_postprocessor_fn = functools.partial(
lm_output_postprocessor_fn, **processor_kwargs)
prediction_file = pathlib.Path(_INPUT_FLAG.value)
internal = False
if not internal:
predictions = dataset.load_predictions(
prediction_file,
lm_output_postprocessor_fn=lm_output_postprocessor_fn)
if _FIRST_N_EXAMPLES_FLAG.value > 0:
first_n_examples = _FIRST_N_EXAMPLES_FLAG.value
logging.warning('Evaluate only the first %d examples', first_n_examples)
predictions = predictions[:first_n_examples]
for episode_prediction in predictions:
for turn_prediction in episode_prediction['turns']:
if 'eval_results' in turn_prediction:
logging.warning(
'Input prediction file is already evalauted. '
'Will rewrite existing evaluations')
del turn_prediction['eval_results']
original_predictions = predictions
if _SPLIT_EPISODE_FLAG.value:
predictions = split_episodes(original_predictions)
logging.info('Generated %d split episodes.', len(predictions))
num_work_units = _NUM_WORK_UNITS_FLAG.value
work_unit_id = _WORK_UNIT_ID_FLAG.value
is_main_unit = work_unit_id == 0
if num_work_units > 1:
num_total_predictions = len(predictions)
predictions = get_work_unit_input_slice(
predictions, work_unit_id, num_work_units)
logging.info(
'Workunit %d gets %s examples out of %s',
work_unit_id, len(predictions), num_total_predictions)
runtime_artifact_root = _ARTIFACT_ROOT_FLAG.value
num_workers = _WORKER_NUM_FLAG.value
evaluator_config = parse_evaluator_config()
time_start = time.time()
# has_finished = False
# if num_work_units > 1:
# shard_result_file_name = get_shard_result_file_name(
# work_unit_id, num_work_units)
# shard_file_path = os.path.join(_OUTPUT_FLAG.value, shard_result_file_name)
# if gfile.exists(shard_file_path):
# shard_results = json.load(gfile.GFile(shard_file_path, 'r'))
# predictions = shard_results['predictions']
# html_report = shard_results['html_report']
# has_finished = True
if num_workers > 1:
multiprocessing.set_start_method('fork')
mp_context = multiprocessing.get_context('spawn')
workers = []
finished = mp_context.Event()
job_queue = mp_context.Queue()
return_value_queue = mp_context.Queue()
for _ in range(num_workers):
p = WorkerProcess(
runtime_artifact_root, job_queue, return_value_queue, finished,
child_process_timeout_secs=_EPISODE_TIMEOUT_FLAG.value,
evaluator_config=evaluator_config,
use_child_process=True,
use_temp_work_dir=_USE_TEMP_WORK_DIR_FLAG.value)
p.start()
workers.append(p)
for idx, prediction in enumerate(predictions):
job_queue.put((idx, prediction))
return_values = [[], [], []]
num_finished_items = 0
return_value_ids = []
while num_finished_items < len(predictions):
try:
return_value = return_value_queue.get(timeout=5)
idx, return_value = return_value
return_values[0].extend(return_value[0]) # metrics
return_values[1].extend(return_value[1]) # metadata
return_values[2].extend(return_value[2]) # predictions
return_value_ids.append(idx) # example index
num_finished_items += 1
except queue.Empty as e:
logging.debug('[Main] Checking worker processes...')
num_alive_workers = len([proc for proc in workers if proc.is_alive()])
logging.debug('[Main] Number of alive workers: %d', num_alive_workers)
if num_alive_workers < len(workers):
logging.error(
'[Main] One worker process stopped. Kill other processes')
worker_proc: WorkerProcess
for worker_proc in workers:
if not worker_proc.is_alive():
logging.error('Worker exited with code: %s', worker_proc.exitcode)
worker_proc.kill()
raise RuntimeError('Some worker processes failed') from e
for i in range(3):
return_values[i] = sorted(
zip(return_values[i], return_value_ids),
key=lambda x: x[1])
return_values[i] = [x[0] for x in return_values[i]]
finished.set()
logging.info('[Main] Got all results.')
for worker_proc in workers:
worker_proc.join()
logging.info('[Main] All worker processes stopped.')
episode_eval_results = return_values[0]
html_report = '\n'.join(meta['html_report'] for meta in return_values[1])
edited_predictions = return_values[2]
for prediction, edited_prediction in zip(predictions, edited_predictions):
assert (
prediction['metadata']['notebook_name'] ==
edited_prediction['metadata']['notebook_name'])
predictions = edited_predictions
else:
episode_eval_results, metadata_list, _ = eval_fn(
predictions,
runtime_artifact_root,
evaluator_config,
_USE_TEMP_WORK_DIR_FLAG.value,
return_pipe=None)
html_report = '\n'.join(meta['html_report'] for meta in metadata_list)
logging.info('Workunit %d finished evaluation.', work_unit_id)
output_folder = pathlib.Path(_OUTPUT_FLAG.value)
gfile.makedirs(str(output_folder))
# Write the workunit shard of evaluated predictions.
if num_work_units > 1:
file_name = get_shard_result_file_name(work_unit_id, num_work_units)
shard_output = dict(
predictions=predictions,
html_report=html_report,
)
with gfile.GFile(str(output_folder / file_name), 'w') as f:
f.write(
json.dumps(
shard_output,
cls=utils.DataclassJsonEncoder, indent=2))
# Create a sentinel file to signal completion to the main work unit.
with gfile.GFile(str(output_folder / (file_name + '.COMPLETED')), 'w') as f:
f.write('')
logging.info(
'Workunit %d wrote shard results to %s.',
work_unit_id, file_name)
sys.stderr.flush()
if is_main_unit:
# Gather sharded results.
shard_file_paths = []
if num_work_units > 1:
all_shard_predictions = []
html_reports = []
logging.info('Gathering sharded results.')
for unit_id in range(num_work_units):
shard_file_name = get_shard_result_file_name(unit_id, num_work_units)
shard_file_path = str(output_folder / shard_file_name)
logging.info('Loading shard file: %s', shard_file_name)
sys.stderr.flush()
while not gfile.exists(shard_file_path + '.COMPLETED'):
logging.info('Shard file not ready: %s', shard_file_name)
sys.stderr.flush()
time.sleep(5)
shard_results = json.load(gfile.GFile(shard_file_path, 'r'))
shard_file_paths.append(shard_file_path)
shard_file_paths.append(shard_file_path + '.COMPLETED')
all_shard_predictions.extend(shard_results['predictions'])
html_reports.append(shard_results['html_report'])
predictions = all_shard_predictions
html_report = '\n'.join(html_reports)
logging.info('Collected %d shards.', num_work_units)
if _SPLIT_EPISODE_FLAG.value:
predictions, episode_eval_results = merge_split_episodes(
predictions, original_predictions)
# Sanity check the aggregated predictions.
assert len(predictions) == len(original_predictions)
for ep_idx in range(len(original_predictions)):
if 'notebook_name' in predictions[ep_idx]['metadata']:
assert (
predictions[ep_idx]['metadata']['notebook_name'] ==
original_predictions[ep_idx]['metadata']['notebook_name'])
assert (
len(predictions[ep_idx]['turns']) ==
len(original_predictions[ep_idx]['turns']))
with gfile.GFile(str(output_folder / 'eval_report.html'), 'w') as f:
f.write(html_report)
if _OUTPUT_EVALUATED_PREDICTION_FLAG.value:
logging.info('Output evaluation details')
with gfile.GFile(str(output_folder / 'predictions.json'), 'w') as f:
f.write(
json.dumps(predictions, cls=utils.DataclassJsonEncoder, indent=2))
dataset_metrics = (
execution_evaluation.get_dataset_metrics(episode_eval_results))
dataset_metrics['time'] = time.time() - time_start
logging.info('Evaluation results:')
logging.info(json.dumps(dataset_metrics))
with gfile.GFile(str(output_folder / 'eval.json'), 'w') as f:
f.write(json.dumps(dataset_metrics, indent=2, sort_keys=True))
# Delete shard results.
if num_work_units > 1:
for file_path in shard_file_paths:
gfile.remove(file_path)
def main(argv: Sequence[str]) -> None:
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
evaluate_main()
if __name__ == '__main__':
app.run(main)
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for variable_state_utils."""
from absl.testing import absltest
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import PIL
from arcade_nl2code.evaluation import variable_state_utils # pylint:disable=g-bad-import-order
Variable = variable_state_utils.Variable
VariableStateType = variable_state_utils.VariableStateType
extract_delta_execution_state = (
variable_state_utils.extract_delta_execution_state_from_exec_globals)
class VariableStateUtilsTest(absltest.TestCase):
# TODO(pcyin): Add new examples from our annotated dataset.
def test_extract_delta_execution_state_changed_variable(self):
df = pd.DataFrame([
{'A': 1, 'B': 'abc'},
{'A': 2, 'B': 'def'},
{'A': 3, 'B': 'fgh'}])
var_before = {
'pd': pd,
'df': df
}
df = df.copy(deep=True)
df['B'] = df['B'].str.upper()
var_after = {
'df': df
}
delta_state = extract_delta_execution_state(
var_before, var_after)
self.assertDictEqual(
delta_state.states,
{
'df': Variable(df, VariableStateType.CHANGED)
}
)
def test_extract_delta_execution_state_newly_created_variable(self):
df = pd.DataFrame([
{'A': 1, 'B': 'abc'},
{'A': 2, 'B': 'def'},
{'A': 3, 'B': 'fgh'}])
var_before = {
'df': df
}
new_df = df.value_counts()
var_after = {
'new_df': new_df,
'df': df
}
delta_state = extract_delta_execution_state(
var_before, var_after)
self.assertDictEqual(
delta_state.states,
{
'new_df': Variable(new_df, VariableStateType.NEW),
}
)
def test_extract_delta_execution_state_for_plotting(self):
# Create some plots.
plt.plot([1, 2, 3], [1, 2, 3])
var_before = {}
var_after = {'__plt__': plt}
delta_state = variable_state_utils.extract_delta_execution_state(
var_before, var_after, is_plotting=True)
self.assertIn('__figure__', delta_state.states)
figure = delta_state.states['__figure__'].value
self.assertIsInstance(figure, PIL.Image.Image)
def test_extract_reference_execution_state_with_target_variable(self):
data = np.random.normal(size=10)
var_before = {
'data': data
}
var_after = {
'data': data,
'std': data.std(),
'mean': data.mean(),
'max': data.max()
}
delta_state = variable_state_utils.extract_reference_execution_state(
var_before, var_after, target_output_variables=['std', 'mean'])
self.assertDictEqual(
delta_state.states,
{
'std': Variable(data.std(), VariableStateType.NEW),
'mean': Variable(data.mean(), VariableStateType.NEW),
}
)
def test_evaluate_execution_state_having_output_variable(self):
ref_exec_state = {
'other_var': Variable(123.456, VariableStateType.NEW),
'__output__': Variable('test string', VariableStateType.NEW)
}
hyp_exec_state = {
'var1': Variable('auxiliary variable', VariableStateType.NEW),
'__output__': Variable('test string', VariableStateType.NEW)
}
eval_result = variable_state_utils.evaluate_execution_state(
hyp_exec_state, ref_exec_state)
expected = {
'precision': 0.5,
'recall': 1.0,
'accuracy': 1.0
}
self.assertDictEqual(eval_result, expected)
def test_evaluate_execution_state_many_output_variables(self):
ref_exec_state = {
'other_var': Variable(123.456, VariableStateType.NEW),
'target_1': Variable('target string 1', VariableStateType.NEW),
'target_2': Variable('target string 2 unequal', VariableStateType.NEW)
}
hyp_exec_state = {
'output_1': Variable('target string 1', VariableStateType.NEW),
'var1': Variable('auxiliary variable', VariableStateType.NEW),
'output_2': Variable('target string 2', VariableStateType.CHANGED)
}
eval_result = variable_state_utils.evaluate_execution_state(
hyp_exec_state, ref_exec_state,
target_output_variables=['target_1', 'target_2']
)
expected = {
'precision': 1 / 3,
'recall': 0.5,
'accuracy': 0.0
}
self.assertDictEqual(eval_result, expected)
def test_evaluate_execution_state_in_place_variable_change(self):
ref_exec_state = {
'target': Variable('target string', VariableStateType.CHANGED),
'__output__': Variable(None, VariableStateType.NEW)
}
hyp_exec_state = {
'output': Variable('target string', VariableStateType.NEW)
}
eval_result = variable_state_utils.evaluate_execution_state(
hyp_exec_state, ref_exec_state,
)
expected = {
'precision': 1.0,
'recall': 1.0,
'accuracy': 1.0
}
self.assertDictEqual(eval_result, expected)
def test_evaluate_execution_state_fuzzy_and_strict_matching(self):
# Example copied from the test below.
df = pd.DataFrame([
{'a': 1.2, 'b': 2.3, 'c': 22},
{'a': 1.8, 'b': 6.3, 'c': 14},
{'a': 1.9865, 'b': 90.6, 'c': 26}])
df_rearranged = df[['a', 'c', 'b']]
ref_exec_state = {
'__output__': Variable(df, VariableStateType.NEW),
}
hyp_exec_state = {
'__output__': Variable(df_rearranged, VariableStateType.NEW)
}
eval_result = variable_state_utils.evaluate_execution_state(
hyp_exec_state,
ref_exec_state,
evaluation_fn=variable_state_utils.fuzzy_equivalence,
)
expected = {
'precision': 1.0,
'recall': 1.0,
'accuracy': 1.0
}
self.assertDictEqual(eval_result, expected)
eval_result = variable_state_utils.evaluate_execution_state(
hyp_exec_state,
ref_exec_state,
)
expected = {
'precision': 0.0,
'recall': 0.0,
'accuracy': 0.0
}
self.assertDictEqual(eval_result, expected)
def test_variable_fuzzy_equivalence(self):
df = pd.DataFrame([
{'a': 1.2, 'b': 2.3, 'c': 22},
{'a': 1.8, 'b': 6.3, 'c': 14},
{'a': 1.9865, 'b': 90.6, 'c': 26}])
df_different_column_names = df.rename({'a': 'a1', 'c': 'c1'})
self.assertTrue(
variable_state_utils.fuzzy_equivalence(
df, df_different_column_names))
df_slice = df['b']
df_slice_list = df['b'].values.tolist()
self.assertLen(df_slice_list, 3)
self.assertTrue(
variable_state_utils.fuzzy_equivalence(
df_slice, df_slice_list))
self.assertTrue(
variable_state_utils.fuzzy_equivalence(
df_slice_list, df_slice))
df_one_column = df[['a']]
df_one_column_list = df_one_column['a'].values.tolist()
df_one_column_numpy_array = np.array(df_one_column_list)
self.assertLen(df_one_column_list, 3)
self.assertTrue(
variable_state_utils.fuzzy_equivalence(
df_one_column_list, df_one_column))
self.assertTrue(
variable_state_utils.fuzzy_equivalence(
df_one_column_numpy_array, df_one_column))
df_sub_view = df[['c', 'a']]
self.assertTrue(
variable_state_utils.fuzzy_equivalence(
df, df_sub_view))
self.assertFalse(
variable_state_utils.fuzzy_equivalence(df_sub_view, df))
df_single_value = pd.DataFrame([{'Country': 'Japan'}])
self.assertTrue(
variable_state_utils.fuzzy_equivalence(
df_single_value, 'Japan'))
dtype_item = np.array([1.0])[0]
assert not dtype_item.shape
self.assertTrue(
variable_state_utils.fuzzy_equivalence(dtype_item, 1.0))
self.assertTrue(
variable_state_utils.fuzzy_equivalence(dtype_item, [1.0])
)
def test_fuzzy_equivalence_subprocess(self):
df = pd.DataFrame([
{'a': 1.2, 'b': 2.3, 'c': 22},
{'a': 1.8, 'b': 6.3, 'c': 14},
{'a': 1.9865, 'b': 90.6, 'c': 26}])
df_different_column_names = df.rename({'a': 'a1', 'c': 'c1'})
self.assertTrue(
variable_state_utils.fuzzy_equivalence_subprocess(
df, df_different_column_names))
self.assertRaises(
TimeoutError,
variable_state_utils.fuzzy_equivalence_subprocess,
df, df_different_column_names, timeout=0.0000001)
def test_variable_fuzzy_equivalence_between_frame_and_series(self):
series = pd.Series({'EU': 1.000004, 'US': 2})
df = pd.DataFrame(
[
{'Region': 'EU', 'val_1': 1, 'val_2': 2},
{'Region': 'US', 'val_1': 2, 'var_2': 3}
]
).set_index('Region')
self.assertTrue(
variable_state_utils.fuzzy_equivalence(df, series))
df = df.reset_index()
self.assertTrue(
variable_state_utils.fuzzy_equivalence(df, series))
answer_list = df['Region']
self.assertTrue(
variable_state_utils.fuzzy_equivalence(series, answer_list))
def test_variable_fuzzy_equivalence_all_close(self):
self.assertTrue(
variable_state_utils.fuzzy_equivalence(1.000004, 1.0))
self.assertTrue(variable_state_utils.fuzzy_equivalence(
np.array(1.000004), 1))
df_1 = pd.DataFrame(
[
{'Region': 'EU', 'val_1': 9.000004},
{'Region': 'US', 'val_1': 17.912}
]
)
df_2 = pd.DataFrame(
[
{'Region': 'EU', 'val_1': 9.0},
{'Region': 'US', 'val_1': 17.912}
]
)
self.assertTrue(
variable_state_utils.fuzzy_equivalence(df_1, df_2))
df_2.at[0, 'val_1'] = 10
self.assertFalse(
variable_state_utils.fuzzy_equivalence(df_1, df_2))
def test_variable_fuzzy_equivalence_replace_nan(self):
self.assertTrue(
variable_state_utils.fuzzy_equivalence(
[np.nan, 1, 2],
[0, 1, 2],
)
)
self.assertFalse(
variable_state_utils.fuzzy_equivalence(
[np.nan, 1, 2],
[7, 1, 2],
)
)
self.assertFalse(
variable_state_utils.fuzzy_equivalence(
[np.nan, 1, 2],
[0, 1, 2],
disabled_rules=['replace_nan']
)
)
series = pd.Series({'EU': 99.000001, 'US': np.nan})
df = pd.DataFrame(
[
{'Region': 'EU', 'val_1': 99, 'val_2': 2},
{'Region': 'US', 'val_1': 0, 'var_2': 3}
]
).set_index('Region')
self.assertTrue(
variable_state_utils.fuzzy_equivalence(df, series))
df.at[1, 'val_1'] = 8
self.assertFalse(
variable_state_utils.fuzzy_equivalence(df, series))
def test_matching_empty_hyp_sereis(self):
ref = pd.DataFrame([{'name': 'curious', 'name_2': 'person', 'val': 10}])
ref = ref.set_index(['name', 'name_2']).iloc[0]
empty_hyp = pd.Series([], dtype='int64')
self.assertFalse(
variable_state_utils.fuzzy_equivalence(empty_hyp, ref))
ref = pd.DataFrame([
{'col_1': 'a', 'col_2': 'df'},
{'col_1': 'that', 'col_2': 'has'},
{'col_1': 'more', 'col_2': 'rows'},
])
self.assertFalse(
variable_state_utils.fuzzy_equivalence(empty_hyp, ref))
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Replay model predictions for functional correctness evaluation."""
import ast
import base64
import copy
import functools
import gc
import io
import itertools
import logging
import multiprocessing
import os
import pathlib
import sys
import time
import traceback
import typing
from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Union
import uuid
import warnings
import astor
import cloudpickle
import numpy as np
import pandas as pd
import PIL
from arcade_nl2code.evaluation import dataset # pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import execution # pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import variable_state_utils # pylint: disable=g-bad-import-order
# We do not use absl logging since it does not work well with multiprocessing.
logging.basicConfig()
logging.getLogger().setLevel(logging.INFO)
# Disable some tensorflow and numpy warning.
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
warnings.simplefilter(
action='ignore',
category=(FutureWarning, np.VisibleDeprecationWarning))
LmExample = dataset.LmExample
Turn = dataset.Turn
Prediction = Dict[Text, Any]
EpisodePrediction = Dict[Text, Any]
EpisodePredictionList = List[Prediction]
# Evaluation metrics for the predictions of a single NL -> Code example.
ExampleMetrics = List[Dict[Text, Any]]
# Evaluation metrics for an episode consiting of a list of examples.
EpisodeMetrics = List[ExampleMetrics]
Variable = variable_state_utils.Variable
VariableStateType = variable_state_utils.VariableStateType
DeltaExecutionState = variable_state_utils.DeltaExecutionState
EvaluationError = variable_state_utils.EvaluationError
EXECUTION_ERROR_EVAL_MARKER = {'accuracy': 0.0}
INVALID_EXAMPLE_EVAL_MARKER = {'is_valid_example': False}
def restore_environment_modules(libraries: List[Text]):
"""Given a list of imported libraries, unload all other libraries.
This function is used to clean up libraries imported by untrusted code.
TODO(pcyin): Turn this into a context manager.
Args:
libraries: A list of libraries to keep.
"""
for module_name in list(sys.modules):
if module_name not in libraries:
del sys.modules[module_name]
class CodeFormatterForTracing(ast.NodeTransformer):
"""Traverse an AST and applies the following modifications.
1. unwrap print statements:
print(df.head()) --> df.head()
2. save the return value of the last function call to a reserved
variable `__output__`
"""
def __init__(self, capture_all_variables: bool = False):
super(CodeFormatterForTracing, self).__init__()
self.capture_all_variables = capture_all_variables
def visit_Module(self, node: ast.Module) -> ast.Module: # pylint: disable=invalid-name
"""Modify an AST.
Save the output of the last statement to varibale `output`. If it is
a print function like `print(df.std())`, change it to `__output__=df.std()`.
`result = df.call()` will be changed to `__output__ = result = df.call()`
Args:
node: original AST node.
Returns:
the modified AST node.
"""
new_body = []
for stmt_id, stmt in enumerate(node.body):
# Find the last statement.
if stmt_id == len(node.body) - 1 or self.capture_all_variables:
expr_val = None
if isinstance(stmt, ast.Expr):
# and isinstance(stmt.value, (ast.Call, ast.Attribute, ast.Subscript))
# Unwrap print statements.
if (
isinstance(stmt.value, ast.Call) and
isinstance(stmt.value.func, ast.Name) and
stmt.value.func.id == 'print' and
stmt.value.args and
len(stmt.value.args) == 1
):
expr_val = stmt.value.args[0]
else:
expr_val = stmt.value
existing_names = []
captured_var_name = (
'__output__'
if stmt_id == len(node.body) - 1
else f'__tmp_{stmt_id}'
)
elif stmt_id == len(node.body) - 1 and isinstance(stmt, ast.Assign):
existing_names = list(stmt.targets)
expr_val = stmt.value
captured_var_name = '__output__'
if expr_val:
new_stmt = ast.Assign(
targets=(
[ast.Name(id=captured_var_name, ctx=ast.Load())] +
existing_names
),
value=expr_val,
ctx=ast.Load()
)
else:
new_stmt = stmt
new_body.append(new_stmt)
else:
new_body.append(stmt)
return ast.Module(body=new_body)
@classmethod
def preprocess_code_for_tracing(cls, source_code: Text, **kwargs) -> Text:
"""Use the formatter to preprocess a given code snippet."""
inst = cls(**kwargs)
code_ast: ast.Module = ast.parse(source_code)
modified_ast = inst.visit(code_ast)
modified_code = astor.to_source(modified_ast)
return modified_code
def variable_to_html(
var_value: Any,
max_rows: int = 15,
max_columns: int = 15,
) -> Text:
"""Get the HTML encoding of a variable value."""
pd.set_option('display.max_rows', max_rows)
pd.set_option('display.max_columns', max_columns)
if isinstance(var_value, pd.DataFrame):
return var_value.to_html(
max_rows=max_rows, max_cols=max_columns,
show_dimensions=True, classes='rendered_dataframe')
elif isinstance(var_value, PIL.Image.Image):
buffered = io.BytesIO()
var_value.save(buffered, format='PNG')
img_str = base64.b64encode(buffered.getvalue()).decode('ascii')
return f"""<img src="data:image/png;base64, {img_str}" >"""
else:
try:
variable_representation = str(var_value)
except: # pylint: disable=bare-except
try:
variable_representation = repr(var_value)
except: # pylint: disable=bare-except
variable_representation = '<ERROR>'
return f"""<pre><code>{variable_representation}</code></pre>"""
def get_output_html_dict(variables_dict: Dict[Text, Any]) -> Dict[Text, Text]:
"""Get a dict of HTML visualization of output variables."""
output_dict = dict()
# To reduce file size, only show the final output variable if the output
# is present and is not null. Otherwise, include all variables.
variables_to_show = variables_dict.keys()
if variables_dict.get('__output__') is not None:
variables_to_show = ['__output__']
for var_name in variables_to_show:
output_dict[var_name] = variable_to_html(variables_dict[var_name])
return output_dict
def get_dataset_metrics(
episode_eval_results: List[EpisodeMetrics]
) -> Dict[Text, float]:
"""Aggregate and compute dataset level metrics.
Args:
episode_eval_results: A collection of evaluation results of predictions.
An example:
[
[
[
{'accuracy': 1.0}, {'accuracy': 0.0}
] # predictions of a turn
] # list of turns in an episode
] # list of episodes
Returns:
Aggregated evaluation results.
"""
temp_metrics = dict()
episode_metrics_list = []
num_eval_examples = 0
num_total_examples = 0
num_valid_episodes = 0
list_num_hyps = [
len(turn_evals) # pylint: disable=g-complex-comprehension,
for episode_evals in episode_eval_results
for turn_evals in episode_evals
]
sample_size = 1
if list_num_hyps:
sample_size = max(max(list_num_hyps), sample_size)
# Bucketize results with an interval of 10.
k_buckets = list(range(0, sample_size + 1, 10))
# Include the sample size as a bucket as well.
k_buckets.remove(0)
if sample_size % 10 != 0 and sample_size not in k_buckets:
k_buckets.append(sample_size)
for episode_evals in episode_eval_results:
turn_metrics = dict()
is_valid_episode = True
for hyp_evals in episode_evals:
num_total_examples += 1
if hyp_evals:
is_valid = hyp_evals[0] != INVALID_EXAMPLE_EVAL_MARKER
if is_valid:
for key in ['accuracy', 'em', 'bleu']:
if key in hyp_evals[0]:
for k in k_buckets:
(turn_metrics
.setdefault(f'{key}@{k}', [])
.append(max(x.get(key, 0.) for x in hyp_evals[:k])))
num_eval_examples += 1
else:
is_valid_episode = False
# Under rare cases this list can be empty if there is no turn in an
# episode.
if episode_evals:
episode_metrics = dict()
if is_valid_episode:
num_valid_episodes += 1
for k in k_buckets:
key = f'accuracy@{k}'
episode_metrics['episode_' + key] = all(
x == 1.0 for x in turn_metrics[key])
episode_metrics_list.append(episode_metrics)
for key, val in turn_metrics.items():
temp_metrics.setdefault(key, []).extend(val)
metrics = dict()
for key in temp_metrics:
metrics[key] = sum(temp_metrics[key]) / num_eval_examples
if episode_metrics_list:
for key in episode_metrics_list[0]:
metrics[key] = (
sum(x[key] for x in episode_metrics_list) /
num_valid_episodes)
metrics['num_eval_examples'] = num_eval_examples
metrics['num_total_examples'] = num_total_examples
metrics['num_eval_episodes'] = num_valid_episodes
metrics['num_total_episodes'] = len(episode_eval_results)
return metrics
def get_self_consistency_clusters(
hyp_outputs: Dict[int, Any],
state_comparison_function_name: Text = 'fuzzy_match',
timeout: int = 30,
) -> Dict[int, List[int]]:
"""Cluster execution outputs of hypotheses for self-consistency decoding.
Given a list of execution results of indexed hypotheses, cluster those
hypotheses based on their execution results.
TODO(pcyin): Make this function more efficient. For now this function
only implements a simple clustering algorithm by exhaustively comparing
pairs of outputs.
Args:
hyp_outputs: Mapping of hypothesis ID to its execution output.
state_comparison_function_name: Name of state comparison function.
timeout: Timeout in seconds for a single call to the comparison function.
Returns:
A dict of clusters. Each cluster (a list of hypotheses indices) is keyed
by the ID of its first item.
"""
valid_hyp_idx_list = list(hyp_outputs.keys())
# At initilaization, each hypothesis forms its own cluster.
output_clusters: Dict[int, List[int]] = {
hyp_idx: [hyp_idx]
for hyp_idx in valid_hyp_idx_list
}
if state_comparison_function_name == 'fuzzy_match':
def compare_output(a, b):
"""Fuzzy variable equivalence.
It compares `a` and `b` from both directions (`a` as reference and `b` as
hypothesis, and vice versa.)
Args:
a: variable a.
b: variable b.
Returns:
match result.
"""
disabled_rules = ['permute-invariant']
return variable_state_utils.fuzzy_equivalence_subprocess(
a, b, disabled_rules=disabled_rules, timeout=timeout
) or variable_state_utils.fuzzy_equivalence_subprocess(
b, a, disabled_rules=disabled_rules, timeout=timeout)
elif state_comparison_function_name == 'strict_match':
compare_output = variable_state_utils.is_variable_equal
else:
raise ValueError(
'Unknown `state_comparison_function_name`: '
f'{state_comparison_function_name}')
def compare_output_wrapper(a: Any, b: Any) -> bool:
"""Wrapper of `comapre_output` with execption handling.
Args:
a: Variable.
b: Variable.
Returns:
A boolean for matching result.
"""
try:
is_equal = compare_output(a, b)
except Exception as e: # pylint: disable=broad-except
# TODO(pcyin): Fix known issues below.
# 'IntegerArray' object has no attribute 'tolist'
logging.error(
'[get_self_consistency_clusters] Error when comparing variables: %s',
str(e)
)
is_equal = False
return is_equal
already_compared_keys = set()
changed_flag = True
# In each iteration, enuemrate all pairs of clusters (`cluster_a`,
# `cluster_b`). If `cluster_a` and `cluster_b` have the same execution state,
# merge them into `cluster_a` and remove `cluster_b`. Repeat this process
# until no two clusters are equal.
while changed_flag:
changed_flag = False
for cluster_a_idx, cluster_b_idx in itertools.combinations(
output_clusters, 2
):
for key in itertools.product(
output_clusters[cluster_a_idx],
output_clusters[cluster_b_idx]
):
hyp_a_idx, hyp_b_idx = key
if key in already_compared_keys:
continue
output_a = hyp_outputs[hyp_a_idx]
output_b = hyp_outputs[hyp_b_idx]
is_equal = compare_output_wrapper(output_a, output_b)
already_compared_keys.add(key)
if not is_equal:
continue
# Merge cluster_a and cluster_b
new_cluster = (
output_clusters[cluster_a_idx] +
output_clusters[cluster_b_idx])
del output_clusters[cluster_b_idx]
output_clusters[cluster_a_idx] = new_cluster
changed_flag = True
break # for key in itertools.product(...)
if changed_flag:
break # for cluster_a_idx, cluster_b_idx in ...
return output_clusters
def hypothesis_code_execution_wrapper(
code: Text,
context_code: Optional[Text] = None,
exec_globals: Optional[Dict[Text, Any]] = None,
timeout: int = -1,
is_plotting: bool = False,
execution_state_extract_fn: Callable[
..., DeltaExecutionState] = (
variable_state_utils.extract_delta_execution_state),
return_value_pipe: Optional[multiprocessing.connection.Connection] = None
) -> Optional[DeltaExecutionState]:
"""Wrapper function to execute model-predicted code."""
delta_state = None
exec_globals = exec_globals or {}
assert multiprocessing.get_start_method() == 'fork'
if context_code:
context_state = execution.execute_code(
context_code,
exec_globals=exec_globals,
copy_state=False
)
if context_state.error:
exception = ContextCodeExecutionError(
'Error when executing the context code of a prediction.\n'
'This shouldn\'t happen as the context code is the same'
'as the context of the reference code.\n'
f'Context code:\n {context_code}\n'
f'Error text: {context_state.error_text}')
delta_state = DeltaExecutionState(exception=exception)
else:
exec_globals = context_state.exec_globals
if not delta_state:
try:
code_state = execution.execute_code(
code,
exec_globals=exec_globals,
timeout=timeout,
copy_state=True,
close_figures=is_plotting
)
except Exception as e: # pylint: disable=broad-except
delta_state = DeltaExecutionState(exception=e)
else:
if code_state.error:
delta_state = DeltaExecutionState(
exception=RuntimeError(code_state.error_text))
else:
delta_state = execution_state_extract_fn(
exec_globals,
code_state.exec_globals,
is_plotting=is_plotting
)
if return_value_pipe is not None:
time_start = time.time()
logging_header = 'hypothesis_code_execution_wrapper'
logging.debug('[%s] Begin pickling result', logging_header)
try:
serialized_result = variable_state_utils.pickle_execution_state(
delta_state)
except Exception as e: # pylint: disable=broad-except
delta_state = DeltaExecutionState(exception=e)
serialized_result = cloudpickle.dumps(delta_state)
logging.debug(
'[%s] %.2fs took to pickle result (size=%d bytes)',
logging_header, time.time() - time_start, len(serialized_result))
return_value_pipe.send(serialized_result)
return_value_pipe.close()
logging.debug('[%s] Result sent. Process finished.', logging_header)
else:
return delta_state
def get_context_code(
turn: Turn,
*,
context_use_prior_prediction: bool,
turn_idx: Optional[int] = None,
prediction_idx: Optional[int] = None,
episode_prediction: Optional[Dict[Text, Any]] = None,
) -> Text:
"""Extract the context code required to execute the current turn."""
if not context_use_prior_prediction:
return turn.code_context
# When the turns in the same notebooks are split into multiple
# pseudo notebooks for parallel execution, the preprocessed context is
# stored in the following key.
if '__hyp_context_code' in episode_prediction['metadata']:
context_code = episode_prediction['metadata']['__hyp_context_code'][
prediction_idx]
else:
if episode_prediction is None:
raise ValueError('Must specify kwargs when using prior turns'
'to form context')
context_code_chunks = []
for idx, turn_prediction in enumerate(
episode_prediction['turns'][:turn_idx]):
turn_example: LmExample = turn_prediction['metadata']['example']
context_code_chunks.append(turn_example.turn.delta_code_context)
turn_hyp_code = episode_prediction['turns'][idx]['predictions'][
prediction_idx]
context_code_chunks.append(turn_hyp_code)
context_code_chunks.append(turn.delta_code_context)
context_code = '\n'.join(context_code_chunks)
logging.debug(
'Turn: %d, hyp: %d, context code: %s',
turn_idx, prediction_idx, context_code)
return context_code
class ContextCodeExecutionError(RuntimeError):
pass
class StatePickleError(ValueError):
pass
class NotebookEvaluator:
"""Evaluator for functional correctness."""
def __init__(self, runtime_artifacts_path: Union[Text, pathlib.Path]):
self.runtime_artifacts_path = pathlib.Path(runtime_artifacts_path)
def evaluate_episode(
self,
episode_prediction: EpisodePrediction,
top_k: int = -1,
timeout: int = -1,
self_consistency_decoding: bool = False,
state_comparison_function: Text = 'fuzzy_match',
state_comparison_timeout: Optional[float] = None,
self_consistency_comparison_function: Text = 'fuzzy_match',
context_use_prior_prediction: bool = False,
record_eval_result_inplace: bool = True,
return_metadata: bool = True,
return_trace_details: bool = False,
raise_when_reference_execution_error: bool = False,
reuse_state: bool = True,
log_metrics: bool = True,
) -> Union[
EpisodeMetrics,
Tuple[
EpisodeMetrics,
Dict[Text, Any], # Metadata.
]
]:
"""Evaluate a model's predictions for a series of turns in an episode.
Args:
episode_prediction: A dict of model predictions for an episode (notebook).
top_k: Execute and evaluate first k hypotheses for a turn.
timeout: Timeout on exeuction of model predicted code.
self_consistency_decoding: Whether to compute metrics for self-consistency
decoding.
state_comparison_function: Which variable comparison function to use.
state_comparison_timeout: Timeout in seconds for state comparison.
self_consistency_comparison_function: Which variable comparison function
to use for self-consistency decoding.
context_use_prior_prediction: Whether to use the predicted code from prior
turns to form the code context for the current turn, instead of using
the reference programs of prior turns as the context.
record_eval_result_inplace: Whether to modify `episode_prediction` in
place to log evaluation results.
return_metadata: Whether to return metadata (an HTML report).
return_trace_details: Whether to log execution results in
`episode_prediction`.
raise_when_reference_execution_error: Whether to raise an exception if
executing the context and reference code results in an exception.
reuse_state: Whether to reuse execution states of previous turns to speed
up evaluation.
log_metrics: Whether to include visualizations of output variables and
other metrics in the HTML report.
Returns:
A nested list of evaluation results. See `get_dataset_metrics` for the
detailed formats. if `return_metadata` is True, return both the evaluation
results and the metadata dict.
Raises:
RuntimeError: if there is an execution error (when
`raise_when_reference_execution_error` is True).
EvaluationError: if there is error when comparing output variables with
the ground truth.
"""
if state_comparison_function not in ['fuzzy_match', 'strict_match']:
raise ValueError(f'Unknown evaluation mode: {state_comparison_function}')
mp_context = multiprocessing.get_context('fork')
evaluation_fn = (
functools.partial( # pylint: disable=g-long-ternary
variable_state_utils.fuzzy_equivalence_subprocess,
timeout=state_comparison_timeout,
mp_context=mp_context,
)
if state_comparison_function == 'fuzzy_match'
else variable_state_utils.DEFAULT_STATE_COMPARISON_FUNCTION
)
if self_consistency_decoding and not record_eval_result_inplace:
raise ValueError(
'Must enable inplace modification of predictions '
'for self-consistency decoding.')
exec_globals = {}
eval_results = []
html_report = """
<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
</head>
"""
cwd = os.getcwd()
os.chdir(self.runtime_artifacts_path)
notebook_name = episode_prediction['metadata']['notebook_name']
turn_predictions = episode_prediction['turns']
logging.info(
'Executing notebook %s ||| %d turns ||| work dir: %s',
notebook_name,
len(turn_predictions),
self.runtime_artifacts_path)
imported_libraries = list(sys.modules.keys())
turn_prediction: Dict[Text, Any]
for turn_idx, turn_prediction in enumerate(episode_prediction['turns']):
turn_example: LmExample = turn_prediction['metadata']['example']
logging.info('Executing notebook %s ||| turn %d ||| %d predictions',
notebook_name, turn_idx, len(turn_prediction['predictions']))
turn_tags = dataset.get_turn_tags(turn_example.turn)
is_figure_output = is_vis_cell = 'vis' in turn_tags
if record_eval_result_inplace:
turn_prediction['metadata']['tags'] = turn_tags
logging.info(
'Executing notebook %s ||| turn %d ||| '
'Intent: %s ||| tags: %s ||| Reference Code: %s',
notebook_name, turn_idx,
turn_example.turn.intent.value,
turn_tags,
turn_example.turn.code.value.replace('\n', '#NEWLINE#'))
# Record a copy of the output variable for each hypothesis. Used
# in self-consistency decoding.
hyp_outputs: Dict[int, Any] = dict()
# pytype: disable=attribute-error
html_report += f"""
<div>
<h3 style="color:teal">Evaluating Example</h3>
<p><strong>Notebook:</strong> {notebook_name} | <strong>Turn: {turn_idx}</strong></p>
<p><strong>Intent:</strong> {turn_example.turn.intent.value}</p>
<p><strong>Having Visualization:</strong>{is_vis_cell}</p>
<p><strong>Target:</strong></p> <pre><code>{turn_example.turn.code.value}</code></pre>
<p><strong>Target Output Variable:</strong> <pre><code>{turn_example.turn.intent.output_variables}</code></pre></p>
<hr>
</div>"""
# pytype: enable=attribute-error
preprocessed_tgt_code = None
try:
preprocessed_tgt_code = (
CodeFormatterForTracing
.preprocess_code_for_tracing(turn_example.turn.code.value))
except SyntaxError as e:
e.msg = f'Reference Code Parse Error: {e.msg}'
ref_execution_state = DeltaExecutionState(exception=e)
else:
ref_execution_state = self.execute_and_extract_delta_state(
preprocessed_tgt_code,
exec_globals=exec_globals if reuse_state else None,
context_code=(
turn_example.turn.delta_code_context
if reuse_state
else turn_example.turn.code_context),
copy_state=False,
is_plotting=is_vis_cell,
execution_state_extract_fn=functools.partial(
variable_state_utils.extract_reference_execution_state,
get_exec_globals=reuse_state,
target_output_variables=(
turn_example.turn.intent.output_variables)
),
use_child_process=not reuse_state,
raise_error=False
)
restore_environment_modules(imported_libraries)
gc.collect()
target_execution_error = ref_execution_state.exception
is_valid_example_flag = turn_prediction.get('is_valid_example', True)
if (
target_execution_error or
not ref_execution_state.states or
not is_valid_example_flag
):
hyp_eval_results = [INVALID_EXAMPLE_EVAL_MARKER]
if not is_valid_example_flag:
error_message = (
turn_prediction.get('reason', '') or
turn_prediction.get('error_text', ''))
error_summary = error_message
elif target_execution_error:
error_summary = 'Reference code execution error.'
error_message = (
ref_execution_state.exception.__class__.__name__ + ': ' +
str(ref_execution_state.exception))
elif not ref_execution_state.states:
error_summary = 'Ref code has no execution state'
error_message = 'None'
if record_eval_result_inplace:
turn_prediction['is_valid_example'] = False # type: ignore
turn_prediction['error_text'] = error_message
error_message = (
f'Error when executing the reference code for '
f'episdoe {notebook_name}, turn {turn_idx}:\n'
f'Code:\n{preprocessed_tgt_code}\n'
f'Error:{error_message}')
logging.error(error_message.replace('\n', '#NEWLINE#'))
if raise_when_reference_execution_error:
raise RuntimeError(error_message)
# pytype: disable=attribute-error
html_report += f"""
<div>
<h3 style="color:blue">{error_summary}</h3>
<p><strong>Notebook:</strong> {notebook_name}</p>
<p><strong>Intent:</strong> {turn_example.turn.intent.value}</p>
<p><strong>Target:</strong></p> <pre><code>{turn_example.turn.code.value}</code></pre>
<p><strong>Pre-processed Target:</strong></p> <pre><code>{preprocessed_tgt_code}</code></pre>
<p><strong>Error:</strong> <pre><code>{error_message}</code></pre></p>
<hr>
</div>"""
# pytype: enable=attribute-error
else:
hyps = turn_prediction['predictions']
if top_k > 0:
hyps = hyps[:top_k]
hyp_eval_results: List[Dict[Text, Any]] = []
if record_eval_result_inplace:
turn_prediction['is_valid_example'] = True # type: ignore
# Evaluation cache to prevent executing duplicate code.
# Each entry is a dict {'value': Any, 'hits': List[int]}
# with cached evaluation result `value` and the hyp id list
# `hits` that match with this entry.
turn_eval_cache = dict()
hyp: Text
for hyp_idx, hyp in enumerate(hyps):
hyp_logging_header = (
f'Executing notebook {notebook_name} ||| '
f'Turn {turn_idx} ||| Hyp {hyp_idx}')
logging.info(
'%s ||| Code: %s',
hyp_logging_header, hyp.replace('\n', '#NEWLINE#'))
time_start = time.time()
html_report += f"""
<div>
<p><strong>Hyp {hyp_idx}:</strong></p>
<pre><code>{hyp}</code></pre>
</div>"""
# Only use cache when conditioned on oracle code context.
if not context_use_prior_prediction and hyp in turn_eval_cache:
eval_result = copy.deepcopy(turn_eval_cache[hyp]['value'])
turn_eval_cache[hyp]['hits'].append(hyp_idx)
hyp_eval_results.append(eval_result)
logging.info(
'%s: hitting cache, skip evaluation of current turn',
hyp_logging_header)
html_report += """<p>Skip duplicate prediction.</p><hr>"""
continue
has_error = False
error_message = None
try:
preprocessed_hyp_code = (
CodeFormatterForTracing
.preprocess_code_for_tracing(
hyp, capture_all_variables=True))
except: # pylint: disable=bare-except
has_error = True
error_message = 'Parse Error'
if not has_error:
html_report += f"""
<p><strong>Pre-processed Hyp: </strong></p>
<pre><code>{preprocessed_hyp_code}</code></pre>"""
hyp_code_context = get_context_code(
turn_example.turn,
context_use_prior_prediction=context_use_prior_prediction,
turn_idx=turn_idx,
prediction_idx=hyp_idx,
episode_prediction=episode_prediction,
)
try:
hyp_execution_state = self.execute_and_extract_delta_state(
context_code=(
hyp_code_context
if not reuse_state
else None),
code=preprocessed_hyp_code,
exec_globals=(
ref_execution_state.exec_globals_before
if reuse_state
else None
),
timeout=timeout,
copy_state=False,
is_plotting=is_vis_cell,
use_child_process=True,
raise_error=False
)
except TimeoutError:
has_error = True
error_message = 'Timeout Error'
except Exception as e: # pylint: disable=broad-except
error_message = str(e).lower()
if (
'can\'t pickle' in error_message or
'cannot pickle' in error_message or
isinstance(e, (StatePickleError, EOFError, OSError))
):
has_error = True
error_message = f'Pickling or OS Error: {str(e)}'
else:
raise RuntimeError(
f'Execution of predicted code crashed at {notebook_name}'
f' ||| turn {turn_idx} ||| hyp {hyp_idx}') from e
else:
if hyp_execution_state.exception:
has_error = True
error_message = (
hyp_execution_state.exception.__class__.__name__ + ': ' +
str(hyp_execution_state.exception))
logging.info(
'%s: execution done (took %.2fs)',
hyp_logging_header, time.time() - time_start)
time_eval_start = time.time()
eval_result = dict()
if has_error:
eval_result = dict(EXECUTION_ERROR_EVAL_MARKER)
eval_result['execution_error'] = True
eval_result['error_text'] = error_message
logging.error(
'%s: %s',
hyp_logging_header, error_message.replace('\n', '#NEWLINE#'))
# pytype: disable=attribute-error
html_report += f"""
<div>
<h3 style="color:red">Trace Error</h3>
<p><strong>Notebook:</strong> {notebook_name}</p>
<p><strong>Intent:</strong> {turn_example.turn.intent.value}</p>
<p><strong>Target:</strong></p> <pre><code>{turn_example.turn.code.value}</code></pre>
<p><strong>Hyp:</strong></p>
<pre><code>{hyp}</code></pre>
<p><strong>Error Message:</strong></p>
<pre><code>{error_message}</code></pre>
<hr>
</div>
"""
# pytype: enable=attribute-error
else:
# This is only used for self-consistency decoding.
output_variable_name = None
if '__figure__' in hyp_execution_state.states:
output_variable_name = '__figure__'
elif (
'__output__' in hyp_execution_state.states and
hyp_execution_state.states['__output__'].value is not None
):
output_variable_name = '__output__'
if self_consistency_decoding and output_variable_name:
hyp_output = (
hyp_execution_state.states[output_variable_name].value)
try:
hyp_output = copy.deepcopy(hyp_output)
hyp_outputs[hyp_idx] = hyp_output
except: # pylint: disable=bare-except
pass
logging.debug(
'%s ||| Hyp delta execution state: %s',
hyp_logging_header,
', '.join(hyp_execution_state.states.keys()))
logging.debug(
'%s ||| Ref delta execution state: %s',
hyp_logging_header,
', '.join(ref_execution_state.states.keys()))
logging.info('%s: Begin evaluation.', hyp_logging_header)
try:
eval_result, eval_metadata = variable_state_utils.evaluate_execution_state( # pylint: disable=line-too-long
hyp_execution_state.states,
ref_execution_state.states,
target_output_variables=(
['__figure__'] if is_figure_output else
turn_example.turn.intent.output_variables),
evaluation_fn=evaluation_fn,
return_aux=True,
)
eval_result = typing.cast(Dict[str, Any], eval_result)
if log_metrics:
html_report += self.get_functional_correctness_metric_report(
eval_result,
eval_metadata)
# Log HTML-visualization of variables in evaluation result.
if 'ref_output_html' not in turn_prediction:
ref_output_dict = get_output_html_dict(
eval_metadata['ref_output_variables']
)
turn_prediction['ref_output_html'] = ref_output_dict
output_dict = get_output_html_dict(
eval_metadata['hyp_output_variables'])
eval_result['output_html'] = output_dict
except Exception as e: # pylint: disable=broad-except
# Evaluation script could crash for various reasons.
# So we use a broad exception type to catch them.
error_message = (
f'{e.__class__.__name__}: {e}\n' +
traceback.format_exc())
eval_result = dict(EXECUTION_ERROR_EVAL_MARKER)
eval_result['evaluation_error'] = True
eval_result['error_text'] = error_message
# pytype: disable=attribute-error
html_report += f"""
<div>
<h3 style="color:red">Evaluation Error</h3>
<p><strong>Target:</strong> {turn_example.turn.code.value}</p>
<p><strong>Hyp:</strong></p>
<p>{hyp}</p>
<p><strong>Error Message:</strong></p>
<p>{error_message}</p>
</div>
"""
# pytype: enable=attribute-error
logging.error(
'%s: Evaluation error: %s', hyp_logging_header, error_message)
html_report += """<hr>"""
if return_trace_details:
eval_result.update(dict(
ref_execution_state=ref_execution_state.states,
hyp_execution_state=hyp_execution_state.states
))
turn_eval_cache[hyp] = dict(value=eval_result, hits=[])
hyp_eval_results.append(eval_result)
logging.info(
'%s: evaluation done (took %.2fs)',
hyp_logging_header, time.time() - time_eval_start)
if (hyp_idx + 1) % 5 == 0:
time_gc_start = time.time()
gc.collect()
logging.debug(
'%s: GC took %.2fs',
hyp_logging_header, time.time() - time_gc_start)
logging.info(
'%s: execution and evaluation done (took %.2fs)',
hyp_logging_header, time.time() - time_start)
restore_environment_modules(imported_libraries)
if reuse_state and not target_execution_error:
exec_globals = ref_execution_state.exec_globals
if '__output__' in exec_globals:
del exec_globals['__output__']
# Self-consistency decoding
if self_consistency_decoding:
time_start = time.time()
output_clusters = get_self_consistency_clusters(
hyp_outputs,
state_comparison_function_name=self_consistency_comparison_function)
for cluster_idx in output_clusters:
hyp_idx_list = list(output_clusters[cluster_idx])
for hyp_idx in hyp_idx_list:
hyp = hyps[hyp_idx]
for other_hyp_idx in turn_eval_cache[hyp]['hits']:
output_clusters[cluster_idx].append(other_hyp_idx)
html_report += f"""
<div>
<p><strong>Clusters: </strong>{list(output_clusters.values())}</p>
</div>
"""
turn_prediction['hyp_clusters'] = output_clusters
logging.info(
'%s: clustering done (took %.2fs)',
notebook_name, time.time() - time_start)
eval_results.append(hyp_eval_results)
if record_eval_result_inplace:
# pytype: disable=unsupported-operands
# TODO(pcyin): Refactor this code snippet and make it more idiomatic.
turn_prediction['eval_results'] = list(hyp_eval_results)
if return_trace_details:
turn_prediction['ref_trace_result'] = ref_execution_state.copy()
# pytype: enable=unsupported-operands
logging.info('Notebook %s: evaluation done', notebook_name)
# restore_environment_modules(imported_libraries)
os.chdir(cwd)
if return_metadata:
return eval_results, dict(html_report=html_report)
else:
return eval_results
def execute_and_extract_delta_state(
self,
code: Text,
context_code: Optional[Text] = None,
exec_globals: Optional[Dict[Text, Any]] = None,
timeout: int = -1,
copy_state: bool = True,
is_plotting: bool = False,
use_child_process: bool = False,
execution_state_extract_fn: Callable[
..., DeltaExecutionState] = (
variable_state_utils.extract_delta_execution_state),
raise_error: bool = True
) -> DeltaExecutionState:
"""Execute code and its programmatic context and extract delta states.
Args:
code: Code to execute.
context_code: Context code that need to be executed first.
exec_globals: Dict of variables needed in order to execute the context
and the target code.
timeout: Time out.
copy_state: Whether to deep copy `exec_globals` when executing code.
is_plotting: Whether the current code is about plotting using matplotlib.
use_child_process: Whether to execute code in a separate forked
child process.
execution_state_extract_fn: Function to extract delta execution state
before and after executing the input code.
raise_error: Whether to raise any exception occurred during code
execution.
Returns:
A `DeltaExecutionState` object.
Raises:
RuntimeError: For any code exeuction error.
StatePickleError For errors during pickling states.
"""
if use_child_process:
if copy_state:
raise ValueError('`copy_state` must be False for '
'running hyp code in child process.')
mp_context = multiprocessing.get_context('fork')
return_pipe_recv, return_pipe_send = mp_context.Pipe(duplex=False)
exec_process = mp_context.Process(
target=hypothesis_code_execution_wrapper,
args=(code, context_code, exec_globals,
timeout, is_plotting,
execution_state_extract_fn,
return_pipe_send)
)
exec_process.start()
return_pipe_send.close()
serialized_delta_execution_state = return_pipe_recv.recv()
exec_process.join()
try:
hyp_delta_execution_state: DeltaExecutionState = cloudpickle.loads(
serialized_delta_execution_state)
except Exception as e: # pylint: disable=broad-except
raise StatePickleError() from e
if hyp_delta_execution_state.exception and raise_error:
raise hyp_delta_execution_state.exception
else:
# FIXME(pcyin): Sometimes code execution will crash with a segmentation
# fault, possible because that importlib tries to access module caches in
# `sys.module` that are already deleted by restore_environment_modules().
# So we force a GC before executing code.
gc.collect()
if context_code:
context_state = execution.execute_code(
context_code,
exec_globals=exec_globals,
copy_state=copy_state
)
if context_state.error:
raise RuntimeError(
'Error when executing the context code of a prediction. '
'This shouldn\'t happen as the context code is the same'
'as the context of the reference code.\n'
f'Context code:\n {context_code}\n'
f'Error text: {context_state.error_text}')
exec_globals = context_state.exec_globals
hyp_state = execution.execute_code(
code,
exec_globals=exec_globals,
timeout=timeout,
copy_state=True,
close_figures=is_plotting
)
if hyp_state.error:
hyp_delta_execution_state = DeltaExecutionState(
exception=RuntimeError(hyp_state.error_text))
else:
hyp_delta_execution_state = execution_state_extract_fn(
exec_globals, hyp_state.exec_globals,
is_plotting=is_plotting
)
return hyp_delta_execution_state
def get_functional_correctness_metric_report(
self,
eval_result: Dict[Text, Any],
eval_metadata: Dict[Text, Any]
) -> Text:
"""Generate an HTML report of variable matching results."""
def get_div_id():
return 'var_output_' + uuid.uuid4().hex[:8]
variable_list = ', '.join(eval_metadata['ref_output_variables'].keys())
# Variable outputs can be huge. Use a button to toggle it.
div_id = get_div_id()
html_report = f"""
<p><strong>Ref output variables:</strong> {variable_list} </p>
"""
ref_output_html = ''
for var_name, var_value in eval_metadata['ref_output_variables'].items():
var_html = variable_to_html(var_value)
ref_output_html += f"""
<p>{var_name} ({type(var_value).__name__}):</p>
{var_html}
"""
html_report += ref_output_html
variable_list = ', '.join(eval_metadata['hyp_output_variables'].keys())
div_id = get_div_id()
html_report += f"""
<p><strong>Hyp output variables:</strong> {variable_list} </p>
"""
hyp_output_html = ''
for var_name, var_value in eval_metadata['hyp_output_variables'].items():
var_html = variable_to_html(var_value)
hyp_output_html += f"""
<p>{var_name} ({type(var_value).__name__}):</p>
{var_html}
"""
html_report += hyp_output_html
html_report += f"""
<p><strong>Ref -> Hyp match:</strong> {eval_metadata["matches"]}</p>
"""
div_id = get_div_id()
html_wrapper = f"""
<p><span onclick="$('#{div_id}').toggle();">[Toggle to Show Eval Details]</span></p>
<div id="{div_id}" style="display: none;">
{html_report}
</div>
<p><strong>Metrics:</strong> {eval_result}</p>
"""
return html_wrapper
def evaluate_dataset_predictions(
self,
predictions: List[EpisodePrediction],
**kwargs
) -> Dict[Text, Any]:
"""Evaluate predictions on the annotated notebook dataset."""
eval_results = []
for episode_predictions in predictions:
episode_eval_list = self.evaluate_episode(episode_predictions, **kwargs)
eval_results.append(episode_eval_list)
return eval_results
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""ENTRYPOINT for executing notebooks.
"""
import os
import pathlib
import time
from typing import Text
from absl import app
from absl import flags
from absl import logging
_PREDICTION_FILE = flags.DEFINE_string('prediction_file', None, 'input file.')
_OUTPUT_PATH = flags.DEFINE_string('output_path', None, 'output path.')
_ARTIFACT_ROOT_FLAG = flags.DEFINE_string(
'runtime_artifact_root', None,
'Path to the evaluation notebooks that contain artifacts like datasets')
_NUM_WORKERS = flags.DEFINE_integer('num_workers', 15, 'Number of workers.')
_NUM_WORK_UNITS_FLAG = flags.DEFINE_integer(
'num_work_units', 1, 'Number of total parallel work units.')
_WORK_UNIT_ID_FLAG = flags.DEFINE_integer(
'work_unit_id', 0, 'Id of this work unit.')
_EXTRA_ARGS = flags.DEFINE_string('extra_args', '', 'Extra arguments.')
flags.mark_flags_as_required(
['prediction_file', 'output_path', 'runtime_artifact_root'])
def create_cmd() -> Text:
"""Creates command."""
output_path = pathlib.Path(_OUTPUT_PATH.value)
if not output_path.exists():
output_path.mkdir(parents=True, exist_ok=True)
output_path = str(output_path)
cmd = f"""mkdir -p {output_path} && python -m arcade_nl2code.evaluation.execution_evaluation_main \
--prediction_file {_PREDICTION_FILE.value} \
--output_path {output_path} \
--runtime_artifact_root {_ARTIFACT_ROOT_FLAG.value} \
--timeout 30 \
--num_workers {_NUM_WORKERS.value} \
--num_work_units {_NUM_WORK_UNITS_FLAG.value} \
--work_unit_id {_WORK_UNIT_ID_FLAG.value}"""
if _EXTRA_ARGS.value:
cmd = f'{cmd} {_EXTRA_ARGS.value}'
return cmd
def main(_):
cmd = create_cmd()
logging.info('CMD: %s', cmd)
os.system(cmd)
if __name__ == '__main__':
app.run(main)
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utility functions for parsing the annotated notebooks dataset."""
# TODO(pcyin): Replace this redundant file with `annotated_dataset/dataest.py`.
# Currently this file is necessary since docker cannot see parent folders in its
# build context.
import dataclasses
import pathlib
from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Union, NewType
from absl import logging
import dacite
import nbformat
from arcade_nl2code.evaluation import utils # pylint: disable=g-bad-import-order
EpisodePrediction = NewType('EpisodePrediction', Dict[Text, Any])
def int_list_to_tuple(datum: Any, keys: List[Text]) -> Any:
"""Convert list in a pytree into tuple."""
if not isinstance(datum, dict):
return datum
new_datum = dict()
for key, val in datum.items():
new_val = val
if isinstance(val, list) and key in keys:
new_val = tuple(val)
else:
new_val = int_list_to_tuple(new_val, keys)
new_datum[key] = new_val
return new_datum
@dataclasses.dataclass
class Intent:
"""Represent an natural language intent."""
value: Optional[Text] = None
is_cell_intent: bool = False
cell_idx: Optional[int] = None
line_span: Optional[Tuple[int, int]] = None
not_sure: Optional[bool] = None
output_variables: Optional[List[Text]] = None
@property
def is_code_line_intent(self) -> bool:
return not self.is_cell_intent
@dataclasses.dataclass
class Code:
value: Text
cell_idx: Optional[int] = None
num_lines: int = 1
line_span: Optional[Tuple[int, int]] = None
@dataclasses.dataclass
class Turn:
"""A single turn of natural language intent and target code."""
intent: Intent
code: Code
# code context in order to execute any predicted program
code_context: Optional[Text] = None
# incremental code context between the previous turn and the current turn.
delta_code_context: Optional[Text] = None
# Optional metadata dict.
metadata: Optional[Dict[Text, Any]] = None
@classmethod
def from_dict(cls, datum: Dict[Text, Any]) -> 'Turn':
datum = int_list_to_tuple(datum, keys=['line_span'])
example = dacite.from_dict(
data_class=cls, data=datum)
return example
@dataclasses.dataclass
class LmExample:
"""An evaluation example, consiting of intent, code, and its code context."""
# Prompt to the language model, including the intent.
input: Text
turn: Turn
# back reference to the originating notebook.
notebook: Optional[nbformat.NotebookNode] = None
# Optional metadata dict.
metadata: Optional[Dict[Text, Any]] = None
@classmethod
def from_dict(cls, datum: Dict[Text, Any]) -> 'LmExample':
datum = int_list_to_tuple(datum, keys=['line_span'])
example = dacite.from_dict(
data_class=cls, data=datum)
return example
def load_dataset(
dataset_path: Union[Text, pathlib.Path]
) -> List[Dict[Text, Any]]:
"""Load annotated dataset to a list of dicts."""
examples = utils.load_json_or_jsonl_file(dataset_path)
for example in examples:
turn_examples = []
for turn_dict in example['turns']:
turn_example = LmExample.from_dict(turn_dict)
turn_examples.append(turn_example)
example['turns'] = turn_examples
return examples
def get_turn_tags(turn: Turn) -> List[Text]:
"""Get a list of tags of a turn."""
code = turn.code.value
# Is visualization code?
tags = []
if any(kwd in code
for kwd in ['.plot', '.bar(', '.hist(', 'sns.', 'plt.', 'boxplot(']):
tags.append('vis')
return tags
def load_predictions(
predictions_file: pathlib.Path,
lm_output_postprocessor_fn: Optional[Callable[[Text], Text]] = None
) -> List[EpisodePrediction]: # for each notebook
"""Load a model prediction file."""
episode_predictions = utils.load_json_or_jsonl_file(predictions_file)
# pylint: disable=unused-variable
for example_idx, episode_prediction in enumerate(episode_predictions):
assert 'notebook_name' in episode_prediction['metadata']
episode_hyp_list = episode_prediction['turns']
for turn_idx, turn_prediction in enumerate(episode_hyp_list):
example = LmExample.from_dict(
turn_prediction['metadata']['example'])
if lm_output_postprocessor_fn:
hyps = turn_prediction['predictions']
processed_hyps = []
hyp: Text
for hyp in hyps:
hyp = lm_output_postprocessor_fn(hyp)
processed_hyps.append(hyp)
turn_prediction['predictions'] = processed_hyps
# modify in-place
turn_prediction['metadata']['example'] = example
return episode_predictions
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utility functions for notebook LM."""
import dataclasses
import json
import pathlib
from typing import Any, List, Text, Union, cast
from tensorflow.io import gfile
class DataclassJsonEncoder(json.JSONEncoder):
"""Custom json encoder for dataclasses and other Python objects."""
def default(self, o: Any) -> ...:
if dataclasses.is_dataclass(o):
return dataclasses.asdict(o)
elif isinstance(o, pathlib.Path):
return str(o)
return super().default(o)
def load_json_or_jsonl_file(
file_path: Union[pathlib.Path, Text]
) -> List[Any]:
"""Read a list of datum from a json or jsonl file."""
examples = []
with gfile.GFile(str(file_path)) as f:
first_line = f.readline().strip()
f.seek(0)
file_format = 'json' if first_line == '[' else 'jsonl'
if file_format == 'jsonl':
for line in f:
data = json.loads(line)
examples.append(data)
else:
examples = cast(List[Any], json.load(f))
return examples
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for execution."""
import logging
from absl.testing import absltest
from arcade_nl2code.evaluation import execution
class ExecutionTest(absltest.TestCase):
def test_execute_code(self):
cells = [
"""import pandas as pd""",
"""df = pd.DataFrame([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}])""",
"""result = df.max().tolist()"""
]
# Test if the execution result matches with the expected one.
exec_globals = {}
for cell in cells:
trace_result = execution.execute_code(
source_code=cell,
exec_globals=exec_globals,
timeout=-1
)
exec_globals = trace_result.exec_globals
self.assertListEqual(exec_globals['result'], [3, 4])
# Test if timeout is correctly handled.
self.assertRaises(
TimeoutError,
execution.execute_code,
source_code='while True: df.max()',
exec_globals=exec_globals,
timeout=5
)
def test_suppress_executed_code_logging(self):
for suppress_logging in [False, True]:
with self.assertLogs(logging.getLogger(), level='DEBUG') as cm:
execution.execute_code(
"""
import logging
logging.error('This error may not be shown.')
""".strip(),
suppress_logging=suppress_logging
)
logging.error('This error should be shown.')
logs = {r.getMessage() for r in cm.records}
self.assertIn('This error should be shown.', logs)
if suppress_logging:
self.assertNotIn('This error may not be shown.', logs)
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utililiy functions for comparing execution states."""
import copy
import dataclasses
import enum
import functools
import io
import multiprocessing
import numbers
import re
import types
from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Union, cast
from absl import logging
import cloudpickle
import numpy as np
import pandas as pd
import PIL
from PIL import Image # pylint: disable=unused-import
from arcade_nl2code.evaluation import execution # pylint: disable=g-bad-import-order
class VariableStateType(enum.Enum):
NEW = 0
CHANGED = 1
@dataclasses.dataclass
class Variable:
"""A variable entry in execution state."""
value: Any
state_type: VariableStateType
@dataclasses.dataclass
class DeltaExecutionState:
"""Stores the changed states of variables after executing a code snippet."""
states: Optional[Dict[Text, Variable]] = None
# The global variable states (including the context states) after execution.
exec_globals: Optional[Dict[Text, Any]] = None
# The global variable states (including the context states) before execution.
exec_globals_before: Optional[Dict[Text, Any]] = None
exception: Optional[Exception] = None
def copy(self) -> 'ExecutionState':
return DeltaExecutionState(
states=copy.deepcopy(self.states),
exec_globals=(
execution.copy_variable_dict( # pylint: disable=g-long-ternary
cast(Dict[Text, Any], self.exec_globals))
if self.exec_globals is not None
else None),
exception=self.exception
)
COLLECTION_VARIABLE_TYPES = (
pd.DataFrame, pd.Series, pd.Index,
np.ndarray,
list, set, tuple
)
PRIMITIVE_VARIABLE_TYPES = (
str, float, int,
np.generic # e.g., np.int64
)
def to_list(x: Any) -> List[Any]:
if isinstance(x, (pd.DataFrame, pd.Series, pd.Index)):
list_repr = x.values.tolist()
elif isinstance(x, np.ndarray):
list_repr = x.tolist()
else:
# FIXME(pcyin): This can throw an error on non-iterable types.
list_repr = list(x)
return list_repr
def is_nested_list(x: List[Any]) -> bool:
# Check if `x` is a nested list with at least one item.
return (
isinstance(x, list) and
x and
all(isinstance(item, list) for item in x)
)
def flatten_list(x: List[Any]) -> List[Any]:
return [v for lst in x for v in lst] # pylint: disable=g-complex-comprehension
def dtype_scalar_to_python_type(value: Any) -> Any:
if isinstance(value, (np.ndarray, np.generic)):
if value.ndim == 0:
return value.item()
return value
def handle_variable_comparison_error(
func: Callable[..., bool]
) -> Callable[..., bool]:
"""Handle errors during comparing variable values."""
@functools.wraps(func)
def wrapped_func(*args, **kwargs):
try:
return func(*args, **kwargs)
except TypeError as e:
raise EvaluationError(f'Error comparing variables: {e}') from e
return wrapped_func
@handle_variable_comparison_error
def fuzzy_equivalence(
hyp_var: Any,
ref_var: Any,
disabled_rules: Optional[List[Text]] = None,
return_metadata: bool = False
) -> Union[bool, Dict[Text, Any]]:
"""Test if two variables are roughly equivalent.
This function implements a set of heuristics for fuzzy varibale equivalence.
For example, a numpy ndarray and a Python list are considerred "equivalent"
if their underlying values are the same. See tests for more examples.
Args:
hyp_var: Hypothesis variable.
ref_var: Reference variable.
disabled_rules: Optional list of fuzzy equivalence rules to be disabled.
return_metadata: Whether to return metadata/logging information for fuzzy
matching.
Returns:
A boolean value of fuzzy equivalence result, qith an optional metadata dict.
"""
def maybe_with_metadata(result, meta=None):
if return_metadata:
if isinstance(result, np.bool_):
result = result.item()
if not isinstance(result, bool):
logging.error(
'Result=%s (type=%s) and it is not a boolean. '
'Metadata=%s. Changing result to False.',
result, type(result), meta)
result = False
return result, meta
else:
return result
hyp_var = dtype_scalar_to_python_type(hyp_var)
ref_var = dtype_scalar_to_python_type(ref_var)
disabled_rules = disabled_rules or []
replace_nan = 'replace_nan' not in disabled_rules
if replace_nan:
hyp_var = try_fillna(hyp_var)
ref_var = try_fillna(ref_var)
result = is_variable_equal(hyp_var, ref_var)
if result:
return maybe_with_metadata(result)
if (
isinstance(hyp_var, COLLECTION_VARIABLE_TYPES) and
isinstance(ref_var, COLLECTION_VARIABLE_TYPES)
):
x_list_repr = to_list(hyp_var)
y_list_repr = to_list(ref_var)
# Cases like:
# x is a nested list and y is a list
# x = [1.2, 1.8, 1.9865]
# y = [[1.2], [1.8], [1.9865]]
if len(x_list_repr) == len(y_list_repr):
if is_nested_list(x_list_repr):
x_list_repr = flatten_list(x_list_repr)
if is_nested_list(y_list_repr):
y_list_repr = flatten_list(y_list_repr)
# Comparing lists: pd.Series and list, tuple, numpy array.
# This also compares dataframes without considering header information.
try:
if variable_or_list_fuzzy_equivalence(x_list_repr, y_list_repr):
return maybe_with_metadata(
True,
{'functionally_equivalent': True,
'reason': 'compare_lists'}
)
except: # pylint: disable=bare-except
pass
if isinstance(hyp_var, pd.Series):
# Reset index of hyp frames as a normal column.
# This will allow the index column to be matched with the reference.
# TODO(pcyin): Check if this causes false positives.
hyp_var = hyp_var.to_frame()
try:
hyp_var = hyp_var.reset_index()
except: # pylint: disable=bare-except
pass
if isinstance(ref_var, pd.Series):
ref_var = ref_var.to_frame()
# Permutation invariance if the hypotheis has more columns
# than the reference.
if (
'permute-invariant' not in disabled_rules and
isinstance(hyp_var, pd.DataFrame) and
isinstance(ref_var, pd.DataFrame) and
len(hyp_var) == len(ref_var) and
len(hyp_var.columns) >= len(ref_var.columns)
):
# TODO(pcyin): Maybe consider other cases where `hyp_var` might have
# fewer number of columns.
small_df = ref_var
large_df = hyp_var
# Check if for each column in the smaller df, it is covered in the larger
# df.
result = True
larger_df_columns_values = [
large_df[col_name].values.tolist()
for col_name
in large_df.columns
]
for col_name in small_df.columns:
col_values = small_df[col_name].values.tolist()
has_matched_column = False
for other_col_values in larger_df_columns_values:
try:
has_matched_column = variable_or_list_fuzzy_equivalence(
col_values, other_col_values)
if not isinstance(has_matched_column, bool):
has_matched_column = False
except Exception as e: # pylint: disable=broad-except
logging.error(
'Variable matching Error: %s: %s.\n'
'Variable 1: %s\nVariable 2: %s',
e.__class__.__name__, str(e),
col_values[:100], other_col_values[:100])
else:
if has_matched_column:
break
if not has_matched_column:
result = False
break
return maybe_with_metadata(
result,
{'functionally_equivalent': result,
'reason': 'permutation_invariance'}
)
elif (
isinstance(hyp_var, PRIMITIVE_VARIABLE_TYPES) and
isinstance(ref_var, COLLECTION_VARIABLE_TYPES) or
isinstance(hyp_var, COLLECTION_VARIABLE_TYPES) and
isinstance(ref_var, PRIMITIVE_VARIABLE_TYPES)
):
# Case 2: if either x xor y is primitive type
if isinstance(hyp_var, PRIMITIVE_VARIABLE_TYPES):
primitive_var, compound_var = hyp_var, ref_var
else:
primitive_var, compound_var = ref_var, hyp_var
compound_var_values = to_list(compound_var)
if is_nested_list(compound_var_values):
compound_var_values = flatten_list(compound_var_values)
if len(compound_var_values) == 1:
compound_var_value = compound_var_values[0]
try:
result = variable_or_list_fuzzy_equivalence(
compound_var_value, primitive_var)
except TypeError:
result = False
return maybe_with_metadata(
result,
{'functionally_equivalent': result,
'reason': 'compare_primitive_and_list'}
)
elif (
isinstance(hyp_var, PRIMITIVE_VARIABLE_TYPES) and
isinstance(ref_var, PRIMITIVE_VARIABLE_TYPES)
):
result = variable_or_list_fuzzy_equivalence(
hyp_var, ref_var)
return maybe_with_metadata(result)
def fuzzy_equivalence_wrapper(
hyp_var: Any,
ref_var: Any,
result_queue: multiprocessing.SimpleQueue,
disabled_rules: Optional[List[Text]] = None,
return_metadata: bool = False,
):
"""Wrapper for `fuzzy_equivalence`."""
result = fuzzy_equivalence(
hyp_var, ref_var,
disabled_rules, return_metadata)
result_queue.put(result)
def fuzzy_equivalence_subprocess(
hyp_var: Any,
ref_var: Any,
disabled_rules: Optional[List[Text]] = None,
return_metadata: bool = False,
mp_context: Optional[multiprocessing.context.BaseContext] = None,
timeout: Optional[int] = None,
) -> Union[bool, Dict[Text, Any]]:
"""Run `fuzzy_equivalence` in a subprocess for robust evaluation."""
mp_context = mp_context or multiprocessing.get_context('fork')
assert mp_context.get_start_method() == 'fork'
result_queue = mp_context.SimpleQueue()
p = mp_context.Process(
target=fuzzy_equivalence_wrapper,
args=(
hyp_var, ref_var,
result_queue,
disabled_rules,
return_metadata,
),
)
p.start()
p.join(timeout)
error_message = None
if p.is_alive():
p.kill()
raise TimeoutError()
elif result_queue.empty():
error_message = (
f'fuzzy_equivalence() crashed with no return result '
f'(code {p.exitcode})')
raise EvaluationError(error_message)
result = result_queue.get()
return result
def try_fillna(
value: Any,
fill_value: float = 0.,
) -> Any:
"""Try to canonicalize NaN items in the value."""
def isnan(x):
v = pd.isna(x)
return isinstance(v, bool) and v
if isinstance(value, list):
return [fill_value if isnan(x) else x for x in value]
try:
if isinstance(value, np.ndarray):
return np.nan_to_num(value, nan=fill_value)
if hasattr(value, 'fillna'):
return value.fillna(fill_value)
except: # pylint: disable=bare-except
pass
return value
def is_variable_equal(var_1: Any, var_2: Any) -> bool:
"""Test if two variables are equal."""
result = False
# Use str(type(...)) since direct type check might fail for two
# `PIL.PngImagePlugin.PngImageFile` objects.
if str(type(var_1)) != str(type(var_2)): # pylint: disable=unidiomatic-typecheck
return False
if isinstance(var_1, (pd.Series, pd.DataFrame, pd.Index)):
result = var_1.equals(var_2)
elif isinstance(var_1, np.ndarray):
result = np.array_equal(var_1, var_2)
elif (
isinstance(var_1, PIL.Image.Image) and
isinstance(var_2, PIL.Image.Image)
):
result = list(var_1.getdata()) == list(var_2.getdata())
else:
try:
result = bool(var_1 == var_2)
except: # pylint: disable=bare-except
result = False
return result
def variable_or_list_fuzzy_equivalence(
var_1: Any,
var_2: Any,
abs_diff: float = 1e-5,
) -> bool:
"""Fuzzy comparison between two values or lists."""
var_1 = dtype_scalar_to_python_type(var_1)
var_2 = dtype_scalar_to_python_type(var_2)
# TODO(pcyin): Make this faster.
if isinstance(var_1, numbers.Number) and isinstance(var_2, numbers.Number):
return abs(var_1 - var_2) <= abs_diff
elif (
isinstance(var_1, COLLECTION_VARIABLE_TYPES) and
isinstance(var_2, COLLECTION_VARIABLE_TYPES)
):
var_1 = np.asarray(var_1)
var_2 = np.asarray(var_2)
if var_1.shape != var_2.shape:
return False
try:
# FIXME(pcyin): This will crash if an array has non-numerical items.
result = np.allclose(var_1, var_2, atol=abs_diff)
except: # pylint: disable=bare-except
result = np.array_equal(var_1, var_2)
else:
result = bool(var_1 == var_2)
return result
def extract_delta_execution_state_from_exec_globals(
variables_before: Dict[Text, Any],
variables_after: Dict[Text, Any]
) -> DeltaExecutionState:
"""Extract modified or newly created variables in the new execution state."""
state_dict = dict()
for var_name, value in variables_after.items():
if var_name == '__builtins__':
continue
if isinstance(value, types.ModuleType):
continue
# Skip function definations.
if callable(value):
continue
if var_name in variables_before:
if not is_variable_equal(value, variables_before[var_name]):
state_dict[var_name] = Variable(
value=value, state_type=VariableStateType.CHANGED)
else:
state_dict[var_name] = Variable(
value=value, state_type=VariableStateType.NEW)
return DeltaExecutionState(states=state_dict)
def figure_to_image(pyplot_object: ...) -> PIL.Image.Image:
"""Returns: a PIL Image object generate from the current active matplotlib figure."""
try:
buf = io.BytesIO()
pyplot_object.savefig(buf, bbox_inches='tight')
buf.seek(0)
image = PIL.Image.open(buf)
except Exception as e: # pylint: disable=broad-except
logging.error('Error saving image: %s', str(e))
# Create a dummy image.
image = PIL.Image.new('RGB', (10, 10))
return image
def extract_delta_execution_state(
variables_before: Dict[Text, Any],
variables_after: Dict[Text, Any],
is_plotting: bool = False
) -> DeltaExecutionState:
"""Extract delta execution states with special cases like plotting."""
if (
is_plotting and
'__plt__' in variables_after and
hasattr(variables_after['__plt__'], 'savefig')
):
fig = figure_to_image(variables_after['__plt__'])
delta_state = DeltaExecutionState(states={
'__figure__': Variable(fig, state_type=VariableStateType.NEW)
})
else:
delta_state = extract_delta_execution_state_from_exec_globals(
variables_before, variables_after)
return delta_state
def extract_reference_execution_state(
variables_before: Dict[Text, Any],
variables_after: Dict[Text, Any],
is_plotting: bool = False,
target_output_variables: Optional[List[Text]] = None,
get_exec_globals: bool = False
) -> DeltaExecutionState:
"""Extract modified or newly created variables in the new execution state."""
is_figure_output = (
is_plotting and
'__plt__' in variables_after and
hasattr(variables_after['__plt__'], 'savefig')
)
if is_figure_output:
fig = Variable(
figure_to_image(variables_after['__plt__']),
state_type=VariableStateType.NEW)
ref_execution_state = DeltaExecutionState(
states={'__figure__': fig})
variables_after['__plt__'].close('all')
del variables_after['__plt__']
elif target_output_variables:
state_dict = dict()
for var_name in target_output_variables:
if var_name not in variables_after:
raise ValueError(f'Variable [{var_name}] is not in the context.')
state_type = (
VariableStateType.NEW
if var_name not in variables_before
else VariableStateType.CHANGED
)
state_dict[var_name] = Variable(
value=variables_after[var_name], state_type=state_type)
ref_execution_state = DeltaExecutionState(states=state_dict)
else:
ref_execution_state = extract_delta_execution_state_from_exec_globals(
variables_before, variables_after)
if get_exec_globals:
ref_execution_state.exec_globals = variables_after
ref_execution_state.exec_globals_before = variables_before
return ref_execution_state
def ensure_serializable(
variable_dict: Optional[
Union[
Dict[Text, Variable],
Dict[Text, Any],
]
]
) -> Optional[
Union[
Dict[Text, Variable],
Dict[Text, Any],
]
]:
"""Only keep serializable variables in a dict."""
if not variable_dict:
return variable_dict
new_dict = dict()
unserializable_types = [re.Match]
for name, value in variable_dict.items():
if isinstance(value, Variable):
var_value = value.value
else:
var_value = value
if any(
isinstance(var_value, cls_type)
for cls_type in unserializable_types
):
continue
new_dict[name] = value
return new_dict
def pickle_execution_state(state: DeltaExecutionState) -> bytes:
"""Searilize execution state to bytes."""
state = DeltaExecutionState(
state.states,
state.exec_globals,
state.exec_globals_before,
state.exception,
)
state.exec_globals = ensure_serializable(state.exec_globals)
state.exec_globals_before = ensure_serializable(state.exec_globals_before)
state.states = ensure_serializable(state.states)
return cloudpickle.dumps(state)
class EvaluationError(ValueError):
pass
DEFAULT_STATE_COMPARISON_FUNCTION = lambda x, y, return_metadata: ( # pylint: disable=g-long-lambda
is_variable_equal(x, y), {}
)
def evaluate_execution_state(
pred_execution_state: Dict[Text, Variable],
target_execution_state: Dict[Text, Variable],
evaluation_fn: Optional[Callable[[...], bool]] = None,
target_output_variables: Optional[List[Text]] = None,
return_aux: bool = False
) -> Union[Dict[Text, float], Tuple[Dict[Text, float], Dict[Text, Any]]]:
"""Compare variable values in hyp and ref executions.
Two cases:
1. __output__ = df.some_api_call()
2. __output__ = df.inplace_modify() (__output__ == None)
We compare the following of variables in two states: any changed dataframe,
and the __output__ variable, if it is not None.
Args:
pred_execution_state: the execution state of predicted code, which
contains changed or newly created variables after execution the
predicted code.
target_execution_state: the execution state of target code.
evaluation_fn: evaluation function to use.
target_output_variables: named annotated output variables, if any.
return_aux: whether to return metadata.
Raises:
EvaluationError: if there is anything wrong.
Returns:
A dict of evauluation metrics and metadata.
"""
# TODO(pcyin): we cannot guarantee the output variable names actually match.
evaluation_fn = evaluation_fn or DEFAULT_STATE_COMPARISON_FUNCTION
ref_output_variable_states = {}
if target_output_variables:
if not all(
var_name
in target_execution_state
for var_name in target_output_variables
):
raise EvaluationError('Not all target output variables are '
'included in the target execution state.')
ref_output_variable_states = {
var_name: target_execution_state[var_name].value
for var_name
in target_output_variables
}
else:
ref_has_output_variable = (
'__output__' in target_execution_state and
target_execution_state['__output__'].value is not None)
if ref_has_output_variable:
ref_output_variable_states['__output__'] = (
target_execution_state['__output__'].value)
else:
# Use the changed dataframe as the output variable.
for var_name, var in target_execution_state.items():
if (
var_name != '__output__' and
var.state_type == VariableStateType.CHANGED
):
ref_output_variable_states[var_name] = var.value
if not ref_output_variable_states:
raise EvaluationError('No target result variables to evaluate against.')
# For hyp variables, we include all the possible ones.
hyp_output_variable_states = {}
for var_name, var in pred_execution_state.items():
is_result_variable = False
if isinstance(var.value, (pd.Series, pd.DataFrame, pd.Index)):
is_result_variable = True
elif isinstance(var.value, (np.ndarray, np.generic)):
is_result_variable = True
elif isinstance(
var.value, (
COLLECTION_VARIABLE_TYPES +
PRIMITIVE_VARIABLE_TYPES)
):
is_result_variable = True
elif isinstance(var.value, PIL.Image.Image):
is_result_variable = True
elif var_name == '__output__' and var.value is not None:
is_result_variable = True
if is_result_variable:
hyp_output_variable_states[var_name] = var.value
logging.debug('Hyp potential output variables: %s',
', '.join(hyp_output_variable_states.keys()))
logging.debug('Ref output variables: %s',
', '.join(ref_output_variable_states.keys()))
num_match = 0
matches = []
for tgt_var_name, tgt_var in ref_output_variable_states.items():
is_match = False
matched_pred_var_name = None
match_metadata = None
# If the last statement in the reference program has valid output, only
# compare it with the last statement of the predicted program.
if tgt_var_name == '__output__':
if '__output__' in hyp_output_variable_states:
is_match, match_metadata = evaluation_fn(
hyp_output_variable_states['__output__'], tgt_var,
return_metadata=True
)
matched_pred_var_name = '__output__'
else:
for pred_var_name, pred_var in hyp_output_variable_states.items():
is_match, match_metadata = evaluation_fn(
pred_var, tgt_var, return_metadata=True)
if is_match:
matched_pred_var_name = pred_var_name
break
if is_match:
logging.debug(
'Reference variable [%s]: matched hyp variable [%s]',
tgt_var_name, matched_pred_var_name)
matches.append((matched_pred_var_name, tgt_var_name, match_metadata))
num_match += 1
metrics = {
'precision': (
(num_match / len(pred_execution_state))
if pred_execution_state else 0),
'recall': num_match / len(ref_output_variable_states),
'accuracy': float(num_match == len(ref_output_variable_states))
}
logging.debug('Metrics: %s', metrics)
if return_aux:
metadata = dict(
hyp_output_variables=hyp_output_variable_states,
ref_output_variables=ref_output_variable_states,
matches=matches
)
return metrics, metadata
return metrics
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Processors for inputs and predictions of language models."""
from typing import Text
def extract_first_cell_block(
lm_prediction: Text,
remove_comment: bool = False,
keep_preceding_cells: bool = False,
cell_delimiter_style: str = 'nbconvert'
) -> Text:
"""Extract first cell blocks that are not empty."""
def maybe_remove_comment(cell):
if remove_comment:
lines = cell.split('\n')
return '\n'.join(
line for line in lines # pylint:disable=g-complex-comprehension
if (line.strip() and
not line.lstrip().startswith('#') and
not line.lstrip().startswith('%')))
else:
return cell.strip()
if cell_delimiter_style == 'nbconvert':
delimeter = '# In[ ]:'
cells = lm_prediction.split(delimeter)
elif cell_delimiter_style == 'vscode_custom':
cells = []
current_cell_lines = []
for line in lm_prediction.split('\n'):
if line.lstrip().startswith('# %%['):
if current_cell_lines:
cell = '\n'.join(current_cell_lines)
cells.append(cell)
current_cell_lines = []
current_cell_lines.append(line)
if current_cell_lines:
cell = '\n'.join(current_cell_lines)
cells.append(cell)
current_cell_lines = []
elif cell_delimiter_style == 'incoder':
delimeter = '</cell>'
# TODO(pcyin): Parse all cells instead of just the first one.
return lm_prediction.partition(delimeter)[0]
else:
raise ValueError(f'Unknown cell style: {cell_delimiter_style}')
checked_cells = []
for cell in cells:
lines = cell.strip().split('\n')
if any(
(line.strip() and # pylint:disable=g-complex-comprehension
not line.lstrip().startswith('#') and
not line.lstrip().startswith('%'))
for line in lines
):
cell = maybe_remove_comment(cell)
if keep_preceding_cells:
if cell_delimiter_style == 'nbconvert':
delimeter = '\n\n\n' + delimeter + '\n\n\n'
return delimeter.join(checked_cells + [cell])
else:
return '\n\n'.join(checked_cells + [cell])
else:
return cell
else:
checked_cells.append(cell.strip())
return ''
def extract_code_from_prompt_with_comment_prefix(
lm_prediction: Text,
prefix: Text = '# Solution: '
) -> Text:
"""Append a comment prefix to the extracted code."""
if not lm_prediction.startswith('#'):
lm_prediction = prefix + lm_prediction
return extract_first_cell_block(
lm_prediction,
remove_comment=False,
keep_preceding_cells=True)
def extract_code_from_prompt_with_comment_prefix_vscode_style(
lm_prediction: Text,
prefix: Text = '# Solution: '
) -> Text:
lm_prediction = prefix + lm_prediction
return extract_first_cell_block(
lm_prediction,
remove_comment=False,
keep_preceding_cells=True,
cell_delimiter_style='vscode_custom'
)
def extract_code_from_prompt_incoder(lm_prediction: Text) -> Text:
return extract_first_cell_block(
lm_prediction, cell_delimiter_style='incoder')
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for execution."""
# pylint: disable=line-too-long
import shutil
from typing import Text, Dict, Any, List
from absl.testing import absltest
from absl.testing import parameterized
import pandas as pd
from arcade_nl2code.evaluation import dataset as dataset_module # pylint: disable=g-bad-import-order
from arcade_nl2code.evaluation import execution_evaluation # pylint: disable=g-bad-import-order
LmExample = dataset_module.LmExample
Turn = dataset_module.Turn
Intent = dataset_module.Intent
Code = dataset_module.Code
EXAMPLE_EPISODE_AND_PREDICTIONS = [
dict(
code="""
import pandas as pd
import matplotlib.pyplot as plt
"""
),
dict(
code="""
alc = pd.read_csv("data.csv")
"""
),
dict(
code="""
# Get the top 10 countires that consume the most beer
output = alc.sort_values('beer_servings', ascending=False)[['country', 'beer_servings']].head(10)
""",
predictions=[
dict(
code="""output = alc.nlargest(10, 'beer_servings')""",
is_correct=True,
is_correct_use_prior_prediction=True,
),
dict(
code="""top10_results = alc.beer_servings.sort_values(ascending=False).head(10)""",
is_correct=False,
is_correct_use_prior_prediction=False,
),
dict(
code="""alc.sort_values(by='beer_servings', ascending=False).head(10)""",
is_correct=True,
is_correct_use_prior_prediction=True,
),
dict(
code="""alc.sort_values(by='beer_servings_not_exist', ascending=False).head(10)""",
is_correct=False, # Execution error.
is_correct_use_prior_prediction=False,
),
],
clusters={
0: [0, 2],
1: [1],
}
),
dict(
code="""
# Find their average beer searvings among top 3 countries.
output.head(3)['beer_servings'].mean()
""",
predictions=[
dict(
code="""alc.sort_values('beer_servings', ascending=False)[:3]['beer_servings'].mean()""",
is_correct=True,
is_correct_use_prior_prediction=True,
),
dict(
code="""top10_results.head(3).mean()""",
is_correct=False, # `top10_countries` not in oracle context.
is_correct_use_prior_prediction=True,
),
dict(
code="""output.head(3)['beer_servings'].mean()""",
is_correct=True,
is_correct_use_prior_prediction=False, # `output` not in prediction context.
),
dict(
code="""
top_df = alc.sort_values('beer_servings', ascending=False)[['country', 'beer_servings']].head(3)
top_df['beer_servings'].mean()""",
is_correct=True,
# FIXME(pcyin): Currently we do not support evaluation of executable prediction if
# its context has an execution error. Such cases should be rare, but worth exploration
# in the future.
is_correct_use_prior_prediction=False, # Prediction context execution error.
),
],
clusters={
0: [0, 2, 3],
}
),
dict(
code="""
import numpy as np
beer = alc.groupby('continent').agg({'beer_servings': np.mean}).sort_values('beer_servings')"""
),
# A plotting example.
dict(
code="""
# Visualize the beer consumption per year for each continent
beer.plot(kind='bar')
""",
predictions=[
dict(
code="""beer.plot(kind='bar')""",
is_correct=True,
is_correct_use_prior_prediction=True,
),
dict(
code="""beer.plot(kind='line')""",
is_correct=False,
is_correct_use_prior_prediction=False,
),
dict(
code="""beer.plot(kind='bar')""",
is_correct=True,
is_correct_use_prior_prediction=False, # Prediction context execution error.
),
dict(
code="""beer.plot(kind='barh')""",
is_correct=False,
is_correct_use_prior_prediction=False,
),
],
clusters={
0: [0, 2],
1: [1],
3: [3],
}
),
dict(
code="""
wine = alc.groupby('continent').agg({'wine_servings': np.mean}).sort_values('wine_servings')
# Visualize the wine cosumption per year by each continent
wine.plot(kind='bar')
plt.title('Wine Servings per Year')
plt.ylabel('Servings')
""",
predictions=[
dict(
code="""
alc.groupby('continent').agg({'wine_servings': 'mean'}).sort_values('wine_servings').plot(kind='bar')
plt.title('Wine Servings per Year')
plt.ylabel('Servings')
""",
is_correct=True,
is_correct_use_prior_prediction=True,
),
dict(
code="""beer.plot(kind='line')""",
is_correct=False,
is_correct_use_prior_prediction=False,
),
dict(
code="""beer.plot(kind='bar')""",
is_correct=False,
is_correct_use_prior_prediction=False,
),
dict(
code="""beer.plot(kind='barh')""",
is_correct=False,
is_correct_use_prior_prediction=False,
),
],
clusters={
0: [0],
1: [1],
2: [2],
3: [3],
}
)
]
def _generate_predictions(
cells: List[Dict[Text, Any]]) -> List[Dict[Text, Any]]:
prev_cell_idx = -1
turn_predictions = []
for cell_idx, cell in enumerate(cells):
is_example_cell = 'predictions' in cell
if is_example_cell:
delta_context_cells = cells[prev_cell_idx + 1: cell_idx]
delta_code_context = '\n'.join(c['code'] for c in delta_context_cells)
code_context = '\n'.join(c['code'] for c in cells[:cell_idx])
example = LmExample(
input=None,
turn=Turn(
intent=Intent(value='Test intent'),
code=Code(value=cell['code']),
code_context=code_context,
delta_code_context=delta_code_context
)
)
predictions = [x['code'] for x in cell['predictions']]
labels = [x['is_correct'] for x in cell['predictions']]
episode_eval_labels = [
x['is_correct_use_prior_prediction']
for x in cell['predictions']
]
turn_predictions.append(dict(
metadata=dict(example=example),
predictions=predictions,
clusters=cell['clusters'],
labels=labels,
episode_eval_labels=episode_eval_labels,
))
prev_cell_idx = cell_idx
episode_prediction = dict(
metadata=dict(notebook_name='test_notebook'),
turns=turn_predictions
)
return episode_prediction
class ExecutionEvaluationTest(parameterized.TestCase):
def test_code_formatter(self):
formatter_cls = execution_evaluation.CodeFormatterForTracing
code = """
r = foo.bar()
foo.bar(1 + 2) > 1
b = foo.output().bar()
""".lstrip()
processed_code = formatter_cls.preprocess_code_for_tracing(code)
self.assertEqual(
processed_code, """
r = foo.bar()
foo.bar(1 + 2) > 1
__output__ = b = foo.output().bar()
""".lstrip())
processed_code = formatter_cls.preprocess_code_for_tracing(
code, capture_all_variables=True)
self.assertEqual(
processed_code, """
r = foo.bar()
__tmp_1 = foo.bar(1 + 2) > 1
__output__ = b = foo.output().bar()
""".lstrip())
@parameterized.parameters(
(True, False),
(False, True),
(False, False),
)
def test_exeuction_evaluation(
self, episode_level_evaluation: bool, reuse_state: bool):
"""Test evaluator end-to-end."""
episode_prediction = _generate_predictions(EXAMPLE_EPISODE_AND_PREDICTIONS)
work_dir = self.create_tempdir()
shutil.copy('evaluation/test_data/data.csv', work_dir.full_path)
evaluator = execution_evaluation.NotebookEvaluator(
runtime_artifacts_path=work_dir.full_path)
eval_results, _ = evaluator.evaluate_episode(
episode_prediction,
timeout=30,
reuse_state=reuse_state,
self_consistency_decoding=not reuse_state,
context_use_prior_prediction=episode_level_evaluation)
self.assertLen(eval_results, len(episode_prediction['turns']))
for turn_idx, turn_eval in enumerate(eval_results):
# As discussed offline, reuse_state is buggy with plotting examples,
# since plotting results are stored in a global singleton instance
# of the imported `matplotlib` module, which causes problems when
# reusing the imported module to execute another prediction.
if turn_idx == 3 and reuse_state:
continue
labels = episode_prediction['turns'][turn_idx]['labels']
self.assertEqual(len(labels), len(turn_eval))
episode_eval_labels = episode_prediction['turns'][turn_idx][
'episode_eval_labels']
for prediction_idx, prediction_eval in enumerate(turn_eval):
predicted_label = prediction_eval['accuracy']
oracle_label = (
episode_eval_labels[prediction_idx]
if episode_level_evaluation
else labels[prediction_idx])
self.assertEqual(
bool(predicted_label),
oracle_label,
msg=(f'Incorrect prediction for turn {turn_idx}, '
f'prediction {prediction_idx}'))
# Check output clustering results.
if not reuse_state and not episode_level_evaluation:
hyp_clusters = episode_prediction['turns'][turn_idx]['hyp_clusters']
expected_clusters = episode_prediction['turns'][turn_idx]['clusters']
self.assertDictEqual(hyp_clusters, expected_clusters)
def test_get_self_consistency_clusters(self):
hyp_outputs = {
1: pd.DataFrame([
{'a': 1.2, 'b': 2.3, 'c': 22},
{'a': 1.9865, 'b': 90.6, 'c': 26}]),
3: [1.2, 2.3, 22],
4: pd.DataFrame([
{'a': 1.2}, {'a': 2.3}, {'a': 22}]),
5: pd.DataFrame([
{'a': 1.2, 'b': 2.3},
{'a': 1.9865, 'b': 90.6}]),
}
clusters = execution_evaluation.get_self_consistency_clusters(hyp_outputs)
expected_clusters = {
1: [1],
3: [3, 4],
5: [5],
}
self.assertDictEqual(clusters, expected_clusters)
def test_get_self_consistency_clusters_strict_match(self):
hyp_outputs = {
1: [1.2, 2.3, 22],
2: pd.DataFrame([
{'a': 1.2}, {'a': 2.3}, {'a': 22}]),
3: pd.DataFrame([
{'a': 1.2}, {'a': 2.3}, {'a': 22.0}]),
}
clusters = execution_evaluation.get_self_consistency_clusters(
hyp_outputs,
state_comparison_function_name='strict_match',
)
expected_clusters = {
1: [1],
2: [2, 3],
}
self.assertDictEqual(clusters, expected_clusters)
if __name__ == '__main__':
absltest.main()
|
# Copyright (C) 2023 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""A script to convert a dataset to a dummy prediction file."""
import argparse
from arcade_nl2code.annotated_dataset import dataset as dataset_module
def dataset_to_dummy_predictions(dataset):
"""Turn a dataset into prediction format using reference as prediction."""
dummy_predictions = []
for episode in dataset:
dummy_episode_prediction = dict(
metadata={k: v for k, v in episode.items() if k != 'turns'},
turns=[]
)
for turn_example in episode['turns']:
turn_pred_entry = dict(
metadata=dict(example=turn_example),
predictions=[
turn_example.turn.code.value
],
)
dummy_episode_prediction['turns'].append(turn_pred_entry)
dummy_predictions.append(dummy_episode_prediction)
return dummy_predictions
if __name__ == '__main__':
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--input', required=True)
arg_parser.add_argument('--output', required=True)
args = arg_parser.parse_args()
dataset = dataset_module.load_dataset(args.input)
dummy_predictions = dataset_to_dummy_predictions(dataset)
dataset_module.save_dataset(dummy_predictions, args.output)
|
"""Data loader class of Abesim generated ExposureResult proto in Riegeli format.
Implemented based on the design here:
https://docs.google.com/document/d/1Ra8HrKQY-1ZigeZd8Pr4IpvOCrA2doGhypahiE6qIjw/edit
"""
import datetime
import io
import math
import riegeli
from agent_based_epidemic_sim.applications.risk_learning import exposures_per_test_result_pb2
from agent_based_epidemic_sim.core import pandemic_pb2
class AbesimExposureDataLoader(object):
"""Data loader of Abesim generated ExposureResult proto in Riegeli format."""
def __init__(self,
file_path,
unconfirmed_exposures=False,
window_around_infection_onset_time=False,
selection_window_left=10,
selection_window_right=0,
include_instances_with_no_exposures=False,
compute_hazard_for_exposures=False,
file_io=io.FileIO):
"""Initialize the Abesim exposure data loder.
Args:
file_path: The path of the Riegeli file that stores ExposureResult protos.
unconfirmed_exposures: Whether to query unconfirmed exposures.
window_around_infection_onset_time: Whether to set the exposure selection
center around the infection onset time (True) or the test administered
time (False).
selection_window_left: Days from the left selection bound to the center.
selection_window_right: Days from the right selection bound to the center.
include_instances_with_no_exposures: If true, instances will be returned
even for those recores that have no exposures.
compute_hazard_for_exposures: Compute the probability of infection from
the recorded doses of the windowed exposures. Note that this label is
not available in a realistic setting, but this can be used to bound the
performance of learning (specifically, lower bound the loss) by using
the true label from the data generation process rather than the sampled
realization of the label.
file_io: A method for constructing a file object for reading.
"""
self.file_path = file_path
self.unconfirmed_exposures = unconfirmed_exposures
self.window_around_infection_onset_time = window_around_infection_onset_time
self.selection_window_left = selection_window_left
self.selection_window_right = selection_window_right
self._include_instances_with_no_exposures = (
include_instances_with_no_exposures
)
self._compute_hazard_for_exposures = compute_hazard_for_exposures
self.file_io = file_io
self.index_reader = riegeli.RecordReader(self.file_io(file_path, mode='rb'))
def __del__(self):
self.index_reader.close()
def reset_file(self):
# Reset to the start of the riegeli file.
self.index_reader.close()
self.index_reader = riegeli.RecordReader(
self.file_io(self.file_path, mode='rb'))
def _seconds_to_mins(self, timedelta):
return timedelta.seconds / 60
def print_all_data(self):
# Util function to print out all data in the riegeli file.
for record in self.index_reader.read_messages(
exposures_per_test_result_pb2.ExposuresPerTestResult.ExposureResult):
print(record)
self.reset_file()
def get_next_batch(self, batch_size=128):
"""Function to query next batch from the index reader."""
def is_confirmed(exposure):
return (exposure.exposure_type ==
exposures_per_test_result_pb2.ExposuresPerTestResult.CONFIRMED)
def is_valid_unconfirmed(exposure):
return (exposure.exposure_type == exposures_per_test_result_pb2
.ExposuresPerTestResult.UNCONFIRMED and
self.unconfirmed_exposures)
def is_contained_in_window(exposure, date_window_left, date_window_right):
return (exposure.exposure_time.ToDatetime() >= date_window_left) and (
exposure.exposure_time.ToDatetime() <= date_window_right)
batch_exposure_list = []
batch_label_list = []
grouping_list = []
batch_hazard_list = []
while (len(batch_label_list) < batch_size and
self.index_reader.pos.numeric != self.index_reader.size()):
record = self.index_reader.read_message(
exposures_per_test_result_pb2.ExposuresPerTestResult.ExposureResult)
if not record:
continue
if (not self.window_around_infection_onset_time or
not record.infection_onset_time):
# Set window around test_administered_date when
# window_around_infection_onset_time is False.
# Also use this window when the record does not have an infection onset
# (corresponds to a true negative).
test_administered_date = record.test_administered_time.ToDatetime()
date_window_left = test_administered_date + datetime.timedelta(
days=-self.selection_window_left)
date_window_right = test_administered_date + datetime.timedelta(
days=self.selection_window_right)
else:
# Set window around infection_onset_time when
# window_around_infection_onset_time is True and
# record.infection_onset_time is not None.
infection_date = record.infection_onset_time.ToDatetime()
date_window_left = infection_date + datetime.timedelta(
days=-self.selection_window_left)
date_window_right = infection_date + datetime.timedelta(
days=self.selection_window_right)
if record.outcome == pandemic_pb2.TestOutcome.Outcome.POSITIVE:
label = 1
elif record.outcome == pandemic_pb2.TestOutcome.Outcome.NEGATIVE:
label = 0
else:
raise ValueError('Invalid label: %s' % record.outcome)
exposure_count = 0
sum_dose = 0
for exposure in record.exposures:
if (is_confirmed(exposure) or
is_valid_unconfirmed(exposure)) and (is_contained_in_window(
exposure, date_window_left, date_window_right)):
# check if duration_since_symptom_onset is valid or None.
if exposure.duration_since_symptom_onset:
duration_since_symptom_onset_day = (
exposure.duration_since_symptom_onset.ToTimedelta().days)
else:
duration_since_symptom_onset_day = None
# If proximity trace is not present (for example, if
# TripleExposureGenerator is used to sample exposures), we add one
# entry to the proximity_trace returned in batch_exposure_list.
if not exposure.proximity_trace:
if not exposure.attenuation:
raise ValueError('Proximity trace or attenuation must be '
'present. Encountered: %s' % exposure)
proximity_trace = [exposure.attenuation]
proximity_trace_temporal_resolution_minute = self._seconds_to_mins(
exposure.duration.ToTimedelta())
else:
proximity_trace = list(exposure.proximity_trace)
proximity_trace_temporal_resolution_minute = self._seconds_to_mins(
exposure.proximity_trace_temporal_resolution.ToTimedelta())
batch_exposure_list.append(
(proximity_trace, duration_since_symptom_onset_day,
proximity_trace_temporal_resolution_minute))
exposure_count += 1
sum_dose += exposure.dose
if (exposure_count == 0 and
not self._include_instances_with_no_exposures):
continue
# Only add instances with valid exposures.
if self._compute_hazard_for_exposures:
scale_factor = -1
prob_infection = 1 - math.exp(scale_factor * sum_dose)
batch_hazard_list.append(prob_infection)
batch_label_list.append(label)
grouping_list.append(exposure_count)
return_val = batch_exposure_list, batch_label_list, grouping_list
if self._compute_hazard_for_exposures:
return_val += (batch_hazard_list,)
return return_val
|
"""Computes infectiousness level for t days after infection, for t=0:14.
Computes the array of infectiousness levels and prints to the screen.
The results can be stored in kInfectivityArray in core/constants.h.
"""
from absl import app
import numpy as np
import scipy.stats
def infectiousness(t):
"""Computes infectiousness level at a given time point.
Parameters are taken from here:
https://github.com/BDI-pathogens/OpenABM-Covid19/blob/master/documentation/parameters/infection_parameters.md
Args:
t: number of days since infection started.
Returns:
Scalar infectiousness level.
"""
mu = 5.5
sigma = 2.14
# For a Gamma(shape=a,rate=inv-scale=b) distribution, mean=a/b, sd=sqrt(a)/b
# hence b=mu/sigma^2, a=b*mu.
b = mu/(sigma**2)
a = b*mu
rv = scipy.stats.gamma(a, loc=0, scale=1 / b)
infect = rv.cdf(t) - rv.cdf(t-1)
return infect
def main(argv):
del argv # Unused.
ts = np.arange(0, 14, 1)
ps = []
for t in ts:
ps.append(infectiousness(t))
print(ps)
if __name__ == '__main__':
app.run(main)
|
"""Tests for abesim_data_loader."""
import io
import os
import tempfile
from absl.testing import absltest
import riegeli
from google.protobuf import text_format
from agent_based_epidemic_sim.applications.risk_learning import exposures_per_test_result_pb2
from agent_based_epidemic_sim.learning import abesim_data_loader
_TMP_FILE_NAME = 'exposures.riegeli'
_TEST_FILE_PATH = ('agent_based_epidemic_sim/agent_based_epidemic_sim/learning/'
'testdata/fake_data_size_30')
def _get_exposures_without_proximity_traces():
return [
text_format.Parse(
"""
test_administered_time { seconds: 86400 }
outcome: POSITIVE
exposures {
exposure_time { seconds: 43200 }
duration_since_symptom_onset { }
proximity_trace_temporal_resolution { }
exposure_type: CONFIRMED
duration { seconds: 1800 }
distance: 1.0
attenuation: 1.0
}
""",
exposures_per_test_result_pb2.ExposuresPerTestResult.ExposureResult())
]
def _get_exposures_missing_required_data():
return [
text_format.Parse(
"""
test_administered_time { seconds: 86400 }
outcome: NEGATIVE
exposures {
exposure_time { seconds: 43200 }
duration_since_symptom_onset { }
proximity_trace_temporal_resolution { }
exposure_type: CONFIRMED
}
""",
exposures_per_test_result_pb2.ExposuresPerTestResult.ExposureResult())
]
def _get_test_data_path():
return os.path.join(absltest.get_default_test_srcdir(), _TEST_FILE_PATH)
def _get_tmp_file_name():
tmp_dir = tempfile.mkdtemp(dir=absltest.get_default_test_tmpdir())
return os.path.join(tmp_dir, _TMP_FILE_NAME)
class AbesimDataLoaderTest(absltest.TestCase):
def test_reads_with_traces_unconfirmed_exposures(self):
data_loader = abesim_data_loader.AbesimExposureDataLoader(
_get_test_data_path(), unconfirmed_exposures=True,
include_instances_with_no_exposures=True)
_, labels, grouping = data_loader.get_next_batch(batch_size=5)
expect_labels = [0, 1, 0, 0, 1]
expect_grouping = [0, 0, 0, 0, 0]
self.assertCountEqual(labels, expect_labels)
self.assertCountEqual(grouping, expect_grouping)
def test_reads_with_traces_no_unconfirmed_exposures(self):
data_loader = abesim_data_loader.AbesimExposureDataLoader(
_get_test_data_path(), unconfirmed_exposures=False,
include_instances_with_no_exposures=True)
_, labels, grouping = data_loader.get_next_batch(batch_size=5)
expect_labels = [0, 1, 0, 0, 1]
expect_grouping = [0, 0, 0, 0, 0]
self.assertCountEqual(labels, expect_labels)
self.assertCountEqual(grouping, expect_grouping)
def test_reads_with_traces_batch_size_too_large(self):
data_loader = abesim_data_loader.AbesimExposureDataLoader(
_get_test_data_path(), unconfirmed_exposures=False,
include_instances_with_no_exposures=True)
_, labels, grouping = data_loader.get_next_batch(batch_size=16)
self.assertLen(labels, 16)
self.assertLen(grouping, 16)
_, labels, grouping = data_loader.get_next_batch(batch_size=16)
self.assertLen(labels, 14)
self.assertLen(grouping, 14)
def test_reads_without_traces(self):
filename = _get_tmp_file_name()
with riegeli.RecordWriter(
io.FileIO(filename, mode='wb'),
options='transpose',
metadata=riegeli.RecordsMetadata()) as writer:
writer.write_messages(_get_exposures_without_proximity_traces())
data_loader = abesim_data_loader.AbesimExposureDataLoader(
filename, unconfirmed_exposures=False)
exposures, labels, grouping = data_loader.get_next_batch(batch_size=1)
self.assertCountEqual(exposures, [([1.0], 0, 30)])
self.assertCountEqual(labels, [1])
self.assertCountEqual(grouping, [1])
def test_reads_without_traces_or_triple_raises(self):
filename = _get_tmp_file_name()
with riegeli.RecordWriter(
io.FileIO(filename, mode='wb'),
options='transpose',
metadata=riegeli.RecordsMetadata()) as writer:
writer.write_messages(_get_exposures_missing_required_data())
data_loader = abesim_data_loader.AbesimExposureDataLoader(
filename, unconfirmed_exposures=False)
with self.assertRaises(ValueError):
_ = data_loader.get_next_batch(batch_size=1)
if __name__ == '__main__':
absltest.main()
|
"""Tests for ens_simulator."""
from absl.testing import absltest
import numpy as np
from agent_based_epidemic_sim.learning import ens_simulator
class EnsSimulatorTest(absltest.TestCase):
def setUp(self):
super().setUp()
self.atten = np.array([50])
self.duration = np.array([15])
self.symptom_days = np.array([-5])
self.params = ens_simulator.ModelParams()
def test_score_increases_with_increased_duration(self):
interaction_long = np.array([30])
interaction_short = np.array([15])
prob_long = ens_simulator.prob_infection_batch(
attenuations=self.atten,
durations=interaction_long,
symptom_days=self.symptom_days,
params=self.params)
prob_short = ens_simulator.prob_infection_batch(
attenuations=self.atten,
durations=interaction_short,
symptom_days=self.symptom_days,
params=self.params)
self.assertGreater(prob_long, prob_short)
def test_score_increases_with_decreased_attenuation(self):
attenuation_far = np.array([80])
attenuation_near = np.array([30])
prob_far = ens_simulator.prob_infection_batch(
attenuations=attenuation_far,
durations=self.duration,
symptom_days=self.symptom_days,
params=self.params)
prob_near = ens_simulator.prob_infection_batch(
attenuations=attenuation_near,
durations=self.duration,
symptom_days=self.symptom_days,
params=self.params)
self.assertGreater(prob_near, prob_far)
if __name__ == '__main__':
absltest.main()
|
"""COVID-19 Exposure Notification System Risk Simulator.
This library provides the required methods to compute the probability of
COVID-19 transmission from a host to a susceptible individual, as a function of
distance (estimated from bluetooth attenuation), duration, and infectiousness of
the host (estimated based on days since symtom onset). This is done using a
standard exponential dose response model, such that,
h(x) = t x f_dist(d) x f_inf(delta)
where, h is the hazard function, x is an interaction between a host and a
susceptible, t is the duration of the interaction in minutes, f_dist(d) is the
rate of viral particles at meters of distance d per unit time, and f_inf(delta)
is the conditional probability of infectious transmission for days since
symptom-onset delta. The parameters of this model are derived from recent papers
on the epidemiology of COVID, and on empirical bluetooth attenuation data.
For a Colab demonstrating this code, go to (broken link).
"""
from dataclasses import dataclass, field
import numpy as np
import scipy.stats
def infectiousness_gaussian(deltas: np.ndarray) -> np.ndarray:
"""Infectiousness as a Gaussian distribution (Briers et al., 2020).
Args:
deltas: np.array of days since symptom onset.
Returns:
Relative probability of infectious transmission.
"""
mu = -0.3
s = 2.75
ps = np.exp(-np.power(deltas - mu, 2) / (2 * s * s))
return ps
def skew_logistic_scaled(x: np.ndarray,
alpha: float,
mu: float,
sigma: float) -> np.ndarray:
"""Calculates the density of the skew logistic PDF (Feretti et al., 2020).
Args:
x: np.array of days since symptom onset.
alpha: The shape parameter of the skew logistic as a float.
mu: The location parameter of the skew logistic as a float.
sigma: The scale parameter of the skew logistic as a float.
Returns:
Relative probability of infectious transmission.
"""
return scipy.stats.genlogistic.pdf(x, alpha, loc=mu, scale=sigma)
def ptost_conditional(deltas: np.ndarray,
incubation: np.ndarray) -> np.ndarray:
"""Probability of transmission conditional on incubation.
ptost(t|k) / max_t(ptost(t|k)),
where, t = days since symptom onset (delta) and k = days of incubation.
Args:
deltas: np.array of days since symptom onset.
incubation: np.array of days of incubation (time from infection to
symptoms).
Returns:
Probability of infectious transmission.
"""
mu = -4
sigma = 1.85
alpha = 5.85
tau = 5.42
fpos = skew_logistic_scaled(deltas, alpha, mu, sigma)
# Error in paper
# fneg = skew_logistic_scaled(ts, alpha, mu, sigma*incubation/tau)
fneg = skew_logistic_scaled(deltas * tau / incubation, alpha, mu, sigma)
ps = fpos
neg = np.where(deltas < 0)
ps[neg] = fneg[neg]
ps = ps / np.max(ps)
return ps
def incubation_dist(t: np.ndarray) -> np.ndarray:
"""Incubation period as a log-normal PDF (Lauer et al., 2020).
Args:
t: np.array of days of incubation (i.e. days from infection to symptoms).
Returns:
Relative probability of the specified incubation time.
"""
mu = 1.621
sig = 0.418
rv = scipy.stats.lognorm(sig, scale=np.exp(mu))
return rv.pdf(t)
def ptost_uncond(deltas: np.ndarray) -> np.ndarray:
"""Marginal probability of transmission (Lauer et al., 2020).
p(t) = sum_{k=1}^14 p(incubation=k) ptost(t|k) / max_t(ptost(t|k)),
where, t = days since symptom onset (delta) and k = days of incubation.
Args:
deltas: np.array of days since symptom onset (TOST).
Returns:
Probability of infectious transmission.
"""
incub_times = np.arange(1, 14, 1)
incub_probs = incubation_dist(incub_times)
tost_probs = np.zeros_like(deltas, dtype=float)
for k, incub in enumerate(incub_times):
ps = ptost_conditional(deltas, incub)
tost_probs += incub_probs[k] * ps
return tost_probs
def infectiousness_skew_logistic(deltas: np.ndarray) -> np.ndarray:
"""Infectiousness as a skew-logistic distribution (Ferretti et al., 2020).
Args:
deltas: np.array of days since symptom onset.
Returns:
Probability of infectious transmission.
"""
infectiousness_times = np.arange(-14, 14 + 1, 0.1)
infectiousness_vals = ptost_uncond(infectiousness_times)
return np.interp(deltas, infectiousness_times, infectiousness_vals)
def dose_curve_quadratic(distances: np.ndarray, dmin: float = 1) -> np.ndarray:
"""Dose as a quadratic function of distance (Briers et al., 2020).
Args:
distances: np.array of meters of distance from the infector.
dmin: 1 based on physics of droplet spread.
Returns:
Dose rate in arbitrary units per unit time.
"""
m = np.power(dmin, 2) / np.power(distances, 2)
return np.minimum(1, m)
def dose_curve_sigmoid(distances: np.ndarray,
slope: float = 1.5,
inflection: float = 4.4) -> np.ndarray:
"""Dose as a sigmoidal decay function of distance (Cencetti et al., 2020).
Args:
distances: np.array of meters of distance from the infector.
slope: the slope of the model heuristically defined as 1.5.
inflection: the inflection point of the model heuristically defined as 4.4.
Returns:
Dose rate in arbitrary units per unit time.
"""
return 1 - 1 / (1 + np.exp(-slope * distances + slope * inflection))
@dataclass
class BleParams:
"""Defines parameters required in converting bluetooth attenuation signals captured by a bluetooth low energy (BLE) sensor into units of distance.
"""
slope: float = 0.21
intercept: float = 3.92
sigma: float = np.sqrt(0.33)
tx: float = 0.0
correction: float = 2.398
name: str = 'briers-lognormal'
def atten_to_dist(attens: np.ndarray, params: BleParams) -> np.ndarray:
"""Converts bluetooth attenuation into expected distance (Lovett et al., 2020).
Args:
attens: np.array of attenuation of the bluetooth signal in dB (decibels).
params: A BleParams object.
Returns:
Expected distance in meters as an np.array.
"""
rssi = params.tx - (attens + params.correction)
return np.exp((np.log(-rssi) - params.intercept) / params.slope)
def dist_to_atten(distances: np.ndarray, params: BleParams) -> np.ndarray:
"""Converts distance into expected bluetooth attenuation (Lovett et al., 2020).
Args:
distances: np.array of distances in meters.
params: A BleParams object.
Returns:
Expected attenuation in dB (decibels) as an np.array.
"""
mu = params.intercept + params.slope * np.log(distances)
rssi = -np.exp(mu)
attens = params.tx - (rssi + params.correction)
return attens
def dist_to_atten_sample(distances: np.ndarray,
params: BleParams) -> np.ndarray:
"""Samples from the lognormal distribution of attenuations for each distance.
Args:
distances: np.array of distances in meters.
params: A BleParams object.
Returns:
Attenuation samples in dB as an np.array.
"""
if params.sigma == 0:
return dist_to_atten(distances, params)
mus = params.intercept + params.slope * np.log(distances)
sigs = params.sigma
rssi = -scipy.stats.lognorm(s=sigs, scale=np.exp(mus)).rvs()
attens = params.tx - (rssi + params.correction)
return attens
@dataclass
class ModelParams:
"""Defines all parameters required to define the distributions of distance, dose and infectiousness.
"""
ble_params: BleParams = field(
default_factory=BleParams
) # may want to change sigma
distance_fun: str = 'sigmoid' # quadratic or sigmoid
distance_dmin: float = 1.0
distance_slope: float = 1.5
distance_inflection: float = 4.4
infectiousness_fun: str = 'skew-logistic' # gaussian or skew-logistic
beta: float = 1e-3 # transmission rate
def prob_infection_batch(attenuations: np.ndarray,
durations: np.ndarray,
symptom_days: np.ndarray,
params: ModelParams,
distances: np.ndarray = None) -> np.ndarray:
"""Calculates the probability of infection given observed values and distributional assumptions.
Args:
attenuations: np.array of bluetooth signal attenuation in dB (decibels).
durations: np.array of interaction duration in minutes.
symptom_days: np.array of days since symptom onset.
params: a ModelParams object.
distances: np.array of distance in meters.
Returns:
Probability of infectious transmision.
"""
if distances is None:
distances = atten_to_dist(attenuations, params.ble_params)
if params.distance_fun == 'quadratic':
fd = dose_curve_quadratic(distances, params.distance_dmin)
elif params.distance_fun == 'sigmoid':
fd = dose_curve_sigmoid(distances, params.distance_slope,
params.distance_inflection)
if params.infectiousness_fun == 'gaussian':
finf = infectiousness_gaussian(symptom_days)
elif params.infectiousness_fun == 'skew-logistic':
finf = infectiousness_skew_logistic(symptom_days)
doses = durations * fd * finf
return 1 - np.exp(-params.beta * doses)
|
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Generate pbtxt configuration file from empirical data."""
import argparse
import json
import os
import pathlib
from typing import Any, Dict, List, TextIO
import urllib.error
import urllib.request
# Root folder for this project.
ROOT = pathlib.Path(os.path.dirname(__file__)) / ".."
# URLs of empirical COVID-19 related data.
C19_OPEN_DATA_API = "https://storage.googleapis.com/covid19-open-data/v2/{key}/main.json"
C19_OPEN_DATA_PROJECT = "https://github.com/GoogleCloudPlatform/covid-19-open-data"
# Used for documentation, defined at global scope to avoid indentation issues.
EXAMPLE = (
"python3 config.py "
"--region-code {key} --date {date} --sim {app} config.pbtxt"
)
DESCRIPTION = f"""
Generate pbtxt configuration file from empirical data. Example usages:
- Seed home/work sim parameters with Spain's population and infected persons on May 1:
$ {EXAMPLE.format(key="ES", date="2020-05-01", app="home_work")}
- Seed home/work sim parameters with data from Washington state as of June 3:
$ {EXAMPLE.format(key="US_WA", date="2020-06-03", app="home_work")}
"""
def read_covid_data(key: str, date: str) -> List[Dict[str, Any]]:
"""Download the data up to `date` for the given region code `key`."""
try:
req = urllib.request.Request(C19_OPEN_DATA_API.format(key=key))
with urllib.request.urlopen(req) as fh:
data = json.load(fh)
columns = data["columns"]
records = ({col: val for col, val in zip(columns, row)}
for row in data["data"])
records = [record for record in records if record["date"] <= date]
assert (
records and records[-1]["date"] == date
), f"Unable to find record with date '{date}'"
return records
except urllib.error.URLError:
raise ValueError(f"Unable to fetch data for region code '{key}'")
def estimate_parameters(records: List[Dict[str, Any]]) -> Dict[str, Any]:
"""Estimate simulation parameters with the provided empirical data."""
latest = records[-1]
# Use the last 15 days of data to compute some estimates.
prev_15_days = records[-15:]
# Population is a static covariate according to this dataset.
population = latest["population"]
# We approximate infectious as the cumulative number of confirmed cases over
# the past 14 days, multiplied by 10 to account for asymptomatic, false
# negatives and untested population.
infectious_count = 10 * sum(
(record["new_confirmed"] for record in prev_15_days[1:])
)
# We assume that the population not infectious + population deceased are no
# longer susceptible. Use count of recovered persons where available, fall
# back to previously confirmed otherwise.
if latest["total_recovered"]:
immune_count = latest["total_recovered"] + latest["total_deceased"]
else:
immune_count = min((record["total_confirmed"] for record in prev_15_days))
# The number of susceptible people are those remaining not in any of the other
# buckets.
susceptible_count = population - immune_count - infectious_count
return {
"population_size": population,
"population_infectious_ratio": infectious_count / population,
"population_susceptible_ratio": susceptible_count / population,
"population_recovered_ratio": immune_count / population,
}
def write_config(fh_out: TextIO, template: str, **params) -> None:
"""Output the config resulting from applying `params` to the `template`."""
with open(template, "r") as fh_in:
content = fh_in.read()
for var, val in params.items():
content = content.replace("{{" + var + "}}", str(val))
fh_out.write(content)
def main():
"""Main entrypoint for the script."""
# Process command-line arguments.
argparser = argparse.ArgumentParser(
description=DESCRIPTION,
formatter_class=argparse.RawTextHelpFormatter,
)
argparser.add_argument(
"--region-code",
type=str,
metavar="CODE",
required=True,
help=f"Region code present in {C19_OPEN_DATA_PROJECT}",
)
argparser.add_argument(
"--date",
type=str,
metavar="YYYY-MM-DD",
required=True,
help="Date in the format YYYY-MM-DD to use as the data source",
)
argparser.add_argument(
"--sim",
type=str,
metavar="APPLICATION",
required=True,
help="Simulation to generate a configuration file for",
)
argparser.add_argument(
"output-file",
type=str,
help="Path to the output pbtxt file",
)
args = argparser.parse_args()
# Retrieve appropriate application template.
templates_folder = ROOT / "configuration_generator" / "templates"
app_tpl = templates_folder / f"{args.sim}.tpl.pbtxt"
assert (
app_tpl.exists()
), f"Template for sim application '{args.sim}' could not be found."
# Read records from remote endpoint.
records = read_covid_data(args.region_code, args.date)
# Estimate the simulation parameters.
params = estimate_parameters(records)
# Write the configuration file with estimated parameters.
with open(getattr(args, "output-file"), "w") as fh:
write_config(fh, str(app_tpl), **params)
if __name__ == "__main__":
main()
|
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
|
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
import unittest
# This is necessary due to how relative imports work in Python, because we don't
# want to create a whole package just for a relatively simple script.
sys.path.append(os.path.abspath(os.path.join(__file__, "..")))
# pylint: disable=g-import-not-at-top
from config import read_covid_data
class TestConfigGenerator(unittest.TestCase):
def _test_read_data_helper(self, key: str, date: str):
records = read_covid_data(key, date)
self.assertTrue(records, "Records are empty or null")
latest = records[-1]
self.assertEqual(latest["date"], date, "Record does not contain date")
self.assertGreater(len(latest.keys()), 0, "Record contains no keys")
self.assertGreater(
len([x for x in latest.values() if x]), 0, "Record values are all null"
)
def test_read_covid_data(self):
self._test_read_data_helper("ES", "2020-05-01")
self._test_read_data_helper("US_WA", "2020-06-03")
if __name__ == "__main__":
sys.exit(unittest.main())
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""BERT finetuning runner with TF-Hub."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import optimization
import run_classifier
import tokenization
import tensorflow as tf
import tensorflow_hub as hub
flags = tf.flags
FLAGS = flags.FLAGS
flags.DEFINE_string(
"bert_hub_module_handle", None,
"Handle for the BERT TF-Hub module.")
def create_model(is_training, input_ids, input_mask, segment_ids, labels,
num_labels, bert_hub_module_handle):
"""Creates a classification model."""
tags = set()
if is_training:
tags.add("train")
bert_module = hub.Module(bert_hub_module_handle, tags=tags, trainable=True)
bert_inputs = dict(
input_ids=input_ids,
input_mask=input_mask,
segment_ids=segment_ids)
bert_outputs = bert_module(
inputs=bert_inputs,
signature="tokens",
as_dict=True)
# In the demo, we are doing a simple classification task on the entire
# segment.
#
# If you want to use the token-level output, use
# bert_outputs["sequence_output"] instead.
output_layer = bert_outputs["pooled_output"]
hidden_size = output_layer.shape[-1].value
output_weights = tf.get_variable(
"output_weights", [num_labels, hidden_size],
initializer=tf.truncated_normal_initializer(stddev=0.02))
output_bias = tf.get_variable(
"output_bias", [num_labels], initializer=tf.zeros_initializer())
with tf.variable_scope("loss"):
if is_training:
# I.e., 0.1 dropout
output_layer = tf.nn.dropout(output_layer, keep_prob=0.9)
logits = tf.matmul(output_layer, output_weights, transpose_b=True)
logits = tf.nn.bias_add(logits, output_bias)
probabilities = tf.nn.softmax(logits, axis=-1)
log_probs = tf.nn.log_softmax(logits, axis=-1)
one_hot_labels = tf.one_hot(labels, depth=num_labels, dtype=tf.float32)
per_example_loss = -tf.reduce_sum(one_hot_labels * log_probs, axis=-1)
loss = tf.reduce_mean(per_example_loss)
return (loss, per_example_loss, logits, probabilities)
def model_fn_builder(num_labels, learning_rate, num_train_steps,
num_warmup_steps, use_tpu, bert_hub_module_handle):
"""Returns `model_fn` closure for TPUEstimator."""
def model_fn(features, labels, mode, params): # pylint: disable=unused-argument
"""The `model_fn` for TPUEstimator."""
tf.logging.info("*** Features ***")
for name in sorted(features.keys()):
tf.logging.info(" name = %s, shape = %s" % (name, features[name].shape))
input_ids = features["input_ids"]
input_mask = features["input_mask"]
segment_ids = features["segment_ids"]
label_ids = features["label_ids"]
is_training = (mode == tf.estimator.ModeKeys.TRAIN)
(total_loss, per_example_loss, logits, probabilities) = create_model(
is_training, input_ids, input_mask, segment_ids, label_ids, num_labels,
bert_hub_module_handle)
output_spec = None
if mode == tf.estimator.ModeKeys.TRAIN:
train_op = optimization.create_optimizer(
total_loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu)
output_spec = tf.contrib.tpu.TPUEstimatorSpec(
mode=mode,
loss=total_loss,
train_op=train_op)
elif mode == tf.estimator.ModeKeys.EVAL:
def metric_fn(per_example_loss, label_ids, logits):
predictions = tf.argmax(logits, axis=-1, output_type=tf.int32)
accuracy = tf.metrics.accuracy(label_ids, predictions)
loss = tf.metrics.mean(per_example_loss)
return {
"eval_accuracy": accuracy,
"eval_loss": loss,
}
eval_metrics = (metric_fn, [per_example_loss, label_ids, logits])
output_spec = tf.contrib.tpu.TPUEstimatorSpec(
mode=mode,
loss=total_loss,
eval_metrics=eval_metrics)
elif mode == tf.estimator.ModeKeys.PREDICT:
output_spec = tf.contrib.tpu.TPUEstimatorSpec(
mode=mode, predictions={"probabilities": probabilities})
else:
raise ValueError(
"Only TRAIN, EVAL and PREDICT modes are supported: %s" % (mode))
return output_spec
return model_fn
def create_tokenizer_from_hub_module(bert_hub_module_handle):
"""Get the vocab file and casing info from the Hub module."""
with tf.Graph().as_default():
bert_module = hub.Module(bert_hub_module_handle)
tokenization_info = bert_module(signature="tokenization_info", as_dict=True)
with tf.Session() as sess:
vocab_file, do_lower_case = sess.run([tokenization_info["vocab_file"],
tokenization_info["do_lower_case"]])
return tokenization.FullTokenizer(
vocab_file=vocab_file, do_lower_case=do_lower_case)
def main(_):
tf.logging.set_verbosity(tf.logging.INFO)
processors = {
"cola": run_classifier.ColaProcessor,
"mnli": run_classifier.MnliProcessor,
"mrpc": run_classifier.MrpcProcessor,
}
if not FLAGS.do_train and not FLAGS.do_eval:
raise ValueError("At least one of `do_train` or `do_eval` must be True.")
tf.gfile.MakeDirs(FLAGS.output_dir)
task_name = FLAGS.task_name.lower()
if task_name not in processors:
raise ValueError("Task not found: %s" % (task_name))
processor = processors[task_name]()
label_list = processor.get_labels()
tokenizer = create_tokenizer_from_hub_module(FLAGS.bert_hub_module_handle)
tpu_cluster_resolver = None
if FLAGS.use_tpu and FLAGS.tpu_name:
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
FLAGS.tpu_name, zone=FLAGS.tpu_zone, project=FLAGS.gcp_project)
is_per_host = tf.contrib.tpu.InputPipelineConfig.PER_HOST_V2
run_config = tf.contrib.tpu.RunConfig(
cluster=tpu_cluster_resolver,
master=FLAGS.master,
model_dir=FLAGS.output_dir,
save_checkpoints_steps=FLAGS.save_checkpoints_steps,
tpu_config=tf.contrib.tpu.TPUConfig(
iterations_per_loop=FLAGS.iterations_per_loop,
num_shards=FLAGS.num_tpu_cores,
per_host_input_for_training=is_per_host))
train_examples = None
num_train_steps = None
num_warmup_steps = None
if FLAGS.do_train:
train_examples = processor.get_train_examples(FLAGS.data_dir)
num_train_steps = int(
len(train_examples) / FLAGS.train_batch_size * FLAGS.num_train_epochs)
num_warmup_steps = int(num_train_steps * FLAGS.warmup_proportion)
model_fn = model_fn_builder(
num_labels=len(label_list),
learning_rate=FLAGS.learning_rate,
num_train_steps=num_train_steps,
num_warmup_steps=num_warmup_steps,
use_tpu=FLAGS.use_tpu,
bert_hub_module_handle=FLAGS.bert_hub_module_handle)
# If TPU is not available, this will fall back to normal Estimator on CPU
# or GPU.
estimator = tf.contrib.tpu.TPUEstimator(
use_tpu=FLAGS.use_tpu,
model_fn=model_fn,
config=run_config,
train_batch_size=FLAGS.train_batch_size,
eval_batch_size=FLAGS.eval_batch_size,
predict_batch_size=FLAGS.predict_batch_size)
if FLAGS.do_train:
train_features = run_classifier.convert_examples_to_features(
train_examples, label_list, FLAGS.max_seq_length, tokenizer)
tf.logging.info("***** Running training *****")
tf.logging.info(" Num examples = %d", len(train_examples))
tf.logging.info(" Batch size = %d", FLAGS.train_batch_size)
tf.logging.info(" Num steps = %d", num_train_steps)
train_input_fn = run_classifier.input_fn_builder(
features=train_features,
seq_length=FLAGS.max_seq_length,
is_training=True,
drop_remainder=True)
estimator.train(input_fn=train_input_fn, max_steps=num_train_steps)
if FLAGS.do_eval:
eval_examples = processor.get_dev_examples(FLAGS.data_dir)
eval_features = run_classifier.convert_examples_to_features(
eval_examples, label_list, FLAGS.max_seq_length, tokenizer)
tf.logging.info("***** Running evaluation *****")
tf.logging.info(" Num examples = %d", len(eval_examples))
tf.logging.info(" Batch size = %d", FLAGS.eval_batch_size)
# This tells the estimator to run through the entire set.
eval_steps = None
# However, if running eval on the TPU, you will need to specify the
# number of steps.
if FLAGS.use_tpu:
# Eval will be slightly WRONG on the TPU because it will truncate
# the last batch.
eval_steps = int(len(eval_examples) / FLAGS.eval_batch_size)
eval_drop_remainder = True if FLAGS.use_tpu else False
eval_input_fn = run_classifier.input_fn_builder(
features=eval_features,
seq_length=FLAGS.max_seq_length,
is_training=False,
drop_remainder=eval_drop_remainder)
result = estimator.evaluate(input_fn=eval_input_fn, steps=eval_steps)
output_eval_file = os.path.join(FLAGS.output_dir, "eval_results.txt")
with tf.gfile.GFile(output_eval_file, "w") as writer:
tf.logging.info("***** Eval results *****")
for key in sorted(result.keys()):
tf.logging.info(" %s = %s", key, str(result[key]))
writer.write("%s = %s\n" % (key, str(result[key])))
if FLAGS.do_predict:
predict_examples = processor.get_test_examples(FLAGS.data_dir)
if FLAGS.use_tpu:
# Discard batch remainder if running on TPU
n = len(predict_examples)
predict_examples = predict_examples[:(n - n % FLAGS.predict_batch_size)]
predict_file = os.path.join(FLAGS.output_dir, "predict.tf_record")
run_classifier.file_based_convert_examples_to_features(
predict_examples, label_list, FLAGS.max_seq_length, tokenizer,
predict_file)
tf.logging.info("***** Running prediction*****")
tf.logging.info(" Num examples = %d", len(predict_examples))
tf.logging.info(" Batch size = %d", FLAGS.predict_batch_size)
predict_input_fn = run_classifier.file_based_input_fn_builder(
input_file=predict_file,
seq_length=FLAGS.max_seq_length,
is_training=False,
drop_remainder=FLAGS.use_tpu)
result = estimator.predict(input_fn=predict_input_fn)
output_predict_file = os.path.join(FLAGS.output_dir, "test_results.tsv")
with tf.gfile.GFile(output_predict_file, "w") as writer:
tf.logging.info("***** Predict results *****")
for prediction in result:
probabilities = prediction["probabilities"]
output_line = "\t".join(
str(class_probability)
for class_probability in probabilities) + "\n"
writer.write(output_line)
if __name__ == "__main__":
flags.mark_flag_as_required("data_dir")
flags.mark_flag_as_required("task_name")
flags.mark_flag_as_required("bert_hub_module_handle")
flags.mark_flag_as_required("output_dir")
tf.app.run()
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import json
import random
import re
import modeling
import six
import tensorflow as tf
class BertModelTest(tf.test.TestCase):
class BertModelTester(object):
def __init__(self,
parent,
batch_size=13,
seq_length=7,
is_training=True,
use_input_mask=True,
use_token_type_ids=True,
vocab_size=99,
hidden_size=32,
num_hidden_layers=5,
num_attention_heads=4,
intermediate_size=37,
hidden_act="gelu",
hidden_dropout_prob=0.1,
attention_probs_dropout_prob=0.1,
max_position_embeddings=512,
type_vocab_size=16,
initializer_range=0.02,
scope=None):
self.parent = parent
self.batch_size = batch_size
self.seq_length = seq_length
self.is_training = is_training
self.use_input_mask = use_input_mask
self.use_token_type_ids = use_token_type_ids
self.vocab_size = vocab_size
self.hidden_size = hidden_size
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.intermediate_size = intermediate_size
self.hidden_act = hidden_act
self.hidden_dropout_prob = hidden_dropout_prob
self.attention_probs_dropout_prob = attention_probs_dropout_prob
self.max_position_embeddings = max_position_embeddings
self.type_vocab_size = type_vocab_size
self.initializer_range = initializer_range
self.scope = scope
def create_model(self):
input_ids = BertModelTest.ids_tensor([self.batch_size, self.seq_length],
self.vocab_size)
input_mask = None
if self.use_input_mask:
input_mask = BertModelTest.ids_tensor(
[self.batch_size, self.seq_length], vocab_size=2)
token_type_ids = None
if self.use_token_type_ids:
token_type_ids = BertModelTest.ids_tensor(
[self.batch_size, self.seq_length], self.type_vocab_size)
config = modeling.BertConfig(
vocab_size=self.vocab_size,
hidden_size=self.hidden_size,
num_hidden_layers=self.num_hidden_layers,
num_attention_heads=self.num_attention_heads,
intermediate_size=self.intermediate_size,
hidden_act=self.hidden_act,
hidden_dropout_prob=self.hidden_dropout_prob,
attention_probs_dropout_prob=self.attention_probs_dropout_prob,
max_position_embeddings=self.max_position_embeddings,
type_vocab_size=self.type_vocab_size,
initializer_range=self.initializer_range)
model = modeling.BertModel(
config=config,
is_training=self.is_training,
input_ids=input_ids,
input_mask=input_mask,
token_type_ids=token_type_ids,
scope=self.scope)
outputs = {
"embedding_output": model.get_embedding_output(),
"sequence_output": model.get_sequence_output(),
"pooled_output": model.get_pooled_output(),
"all_encoder_layers": model.get_all_encoder_layers(),
}
return outputs
def check_output(self, result):
self.parent.assertAllEqual(
result["embedding_output"].shape,
[self.batch_size, self.seq_length, self.hidden_size])
self.parent.assertAllEqual(
result["sequence_output"].shape,
[self.batch_size, self.seq_length, self.hidden_size])
self.parent.assertAllEqual(result["pooled_output"].shape,
[self.batch_size, self.hidden_size])
def test_default(self):
self.run_tester(BertModelTest.BertModelTester(self))
def test_config_to_json_string(self):
config = modeling.BertConfig(vocab_size=99, hidden_size=37)
obj = json.loads(config.to_json_string())
self.assertEqual(obj["vocab_size"], 99)
self.assertEqual(obj["hidden_size"], 37)
def run_tester(self, tester):
with self.test_session() as sess:
ops = tester.create_model()
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
output_result = sess.run(ops)
tester.check_output(output_result)
self.assert_all_tensors_reachable(sess, [init_op, ops])
@classmethod
def ids_tensor(cls, shape, vocab_size, rng=None, name=None):
"""Creates a random int32 tensor of the shape within the vocab size."""
if rng is None:
rng = random.Random()
total_dims = 1
for dim in shape:
total_dims *= dim
values = []
for _ in range(total_dims):
values.append(rng.randint(0, vocab_size - 1))
return tf.constant(value=values, dtype=tf.int32, shape=shape, name=name)
def assert_all_tensors_reachable(self, sess, outputs):
"""Checks that all the tensors in the graph are reachable from outputs."""
graph = sess.graph
ignore_strings = [
"^.*/assert_less_equal/.*$",
"^.*/dilation_rate$",
"^.*/Tensordot/concat$",
"^.*/Tensordot/concat/axis$",
"^testing/.*$",
]
ignore_regexes = [re.compile(x) for x in ignore_strings]
unreachable = self.get_unreachable_ops(graph, outputs)
filtered_unreachable = []
for x in unreachable:
do_ignore = False
for r in ignore_regexes:
m = r.match(x.name)
if m is not None:
do_ignore = True
if do_ignore:
continue
filtered_unreachable.append(x)
unreachable = filtered_unreachable
self.assertEqual(
len(unreachable), 0, "The following ops are unreachable: %s" %
(" ".join([x.name for x in unreachable])))
@classmethod
def get_unreachable_ops(cls, graph, outputs):
"""Finds all of the tensors in graph that are unreachable from outputs."""
outputs = cls.flatten_recursive(outputs)
output_to_op = collections.defaultdict(list)
op_to_all = collections.defaultdict(list)
assign_out_to_in = collections.defaultdict(list)
for op in graph.get_operations():
for x in op.inputs:
op_to_all[op.name].append(x.name)
for y in op.outputs:
output_to_op[y.name].append(op.name)
op_to_all[op.name].append(y.name)
if str(op.type) == "Assign":
for y in op.outputs:
for x in op.inputs:
assign_out_to_in[y.name].append(x.name)
assign_groups = collections.defaultdict(list)
for out_name in assign_out_to_in.keys():
name_group = assign_out_to_in[out_name]
for n1 in name_group:
assign_groups[n1].append(out_name)
for n2 in name_group:
if n1 != n2:
assign_groups[n1].append(n2)
seen_tensors = {}
stack = [x.name for x in outputs]
while stack:
name = stack.pop()
if name in seen_tensors:
continue
seen_tensors[name] = True
if name in output_to_op:
for op_name in output_to_op[name]:
if op_name in op_to_all:
for input_name in op_to_all[op_name]:
if input_name not in stack:
stack.append(input_name)
expanded_names = []
if name in assign_groups:
for assign_name in assign_groups[name]:
expanded_names.append(assign_name)
for expanded_name in expanded_names:
if expanded_name not in stack:
stack.append(expanded_name)
unreachable_ops = []
for op in graph.get_operations():
is_unreachable = False
all_names = [x.name for x in op.inputs] + [x.name for x in op.outputs]
for name in all_names:
if name not in seen_tensors:
is_unreachable = True
if is_unreachable:
unreachable_ops.append(op)
return unreachable_ops
@classmethod
def flatten_recursive(cls, item):
"""Flattens (potentially nested) a tuple/dictionary/list to a list."""
output = []
if isinstance(item, list):
output.extend(item)
elif isinstance(item, tuple):
output.extend(list(item))
elif isinstance(item, dict):
for (_, v) in six.iteritems(item):
output.append(v)
else:
return [item]
flat_output = []
for x in output:
flat_output.extend(cls.flatten_recursive(x))
return flat_output
if __name__ == "__main__":
tf.test.main()
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Extract pre-computed feature vectors from BERT."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import codecs
import collections
import json
import re
import modeling
import tokenization
import tensorflow as tf
flags = tf.flags
FLAGS = flags.FLAGS
flags.DEFINE_string("input_file", None, "")
flags.DEFINE_string("output_file", None, "")
flags.DEFINE_string("layers", "-1,-2,-3,-4", "")
flags.DEFINE_string(
"bert_config_file", None,
"The config json file corresponding to the pre-trained BERT model. "
"This specifies the model architecture.")
flags.DEFINE_integer(
"max_seq_length", 128,
"The maximum total input sequence length after WordPiece tokenization. "
"Sequences longer than this will be truncated, and sequences shorter "
"than this will be padded.")
flags.DEFINE_string(
"init_checkpoint", None,
"Initial checkpoint (usually from a pre-trained BERT model).")
flags.DEFINE_string("vocab_file", None,
"The vocabulary file that the BERT model was trained on.")
flags.DEFINE_bool(
"do_lower_case", True,
"Whether to lower case the input text. Should be True for uncased "
"models and False for cased models.")
flags.DEFINE_integer("batch_size", 32, "Batch size for predictions.")
flags.DEFINE_bool("use_tpu", False, "Whether to use TPU or GPU/CPU.")
flags.DEFINE_string("master", None,
"If using a TPU, the address of the master.")
flags.DEFINE_integer(
"num_tpu_cores", 8,
"Only used if `use_tpu` is True. Total number of TPU cores to use.")
flags.DEFINE_bool(
"use_one_hot_embeddings", False,
"If True, tf.one_hot will be used for embedding lookups, otherwise "
"tf.nn.embedding_lookup will be used. On TPUs, this should be True "
"since it is much faster.")
class InputExample(object):
def __init__(self, unique_id, text_a, text_b):
self.unique_id = unique_id
self.text_a = text_a
self.text_b = text_b
class InputFeatures(object):
"""A single set of features of data."""
def __init__(self, unique_id, tokens, input_ids, input_mask, input_type_ids):
self.unique_id = unique_id
self.tokens = tokens
self.input_ids = input_ids
self.input_mask = input_mask
self.input_type_ids = input_type_ids
def input_fn_builder(features, seq_length):
"""Creates an `input_fn` closure to be passed to TPUEstimator."""
all_unique_ids = []
all_input_ids = []
all_input_mask = []
all_input_type_ids = []
for feature in features:
all_unique_ids.append(feature.unique_id)
all_input_ids.append(feature.input_ids)
all_input_mask.append(feature.input_mask)
all_input_type_ids.append(feature.input_type_ids)
def input_fn(params):
"""The actual input function."""
batch_size = params["batch_size"]
num_examples = len(features)
# This is for demo purposes and does NOT scale to large data sets. We do
# not use Dataset.from_generator() because that uses tf.py_func which is
# not TPU compatible. The right way to load data is with TFRecordReader.
d = tf.data.Dataset.from_tensor_slices({
"unique_ids":
tf.constant(all_unique_ids, shape=[num_examples], dtype=tf.int32),
"input_ids":
tf.constant(
all_input_ids, shape=[num_examples, seq_length],
dtype=tf.int32),
"input_mask":
tf.constant(
all_input_mask,
shape=[num_examples, seq_length],
dtype=tf.int32),
"input_type_ids":
tf.constant(
all_input_type_ids,
shape=[num_examples, seq_length],
dtype=tf.int32),
})
d = d.batch(batch_size=batch_size, drop_remainder=False)
return d
return input_fn
def model_fn_builder(bert_config, init_checkpoint, layer_indexes, use_tpu,
use_one_hot_embeddings):
"""Returns `model_fn` closure for TPUEstimator."""
def model_fn(features, labels, mode, params): # pylint: disable=unused-argument
"""The `model_fn` for TPUEstimator."""
unique_ids = features["unique_ids"]
input_ids = features["input_ids"]
input_mask = features["input_mask"]
input_type_ids = features["input_type_ids"]
model = modeling.BertModel(
config=bert_config,
is_training=False,
input_ids=input_ids,
input_mask=input_mask,
token_type_ids=input_type_ids,
use_one_hot_embeddings=use_one_hot_embeddings)
if mode != tf.estimator.ModeKeys.PREDICT:
raise ValueError("Only PREDICT modes are supported: %s" % (mode))
tvars = tf.trainable_variables()
scaffold_fn = None
(assignment_map,
initialized_variable_names) = modeling.get_assignment_map_from_checkpoint(
tvars, init_checkpoint)
if use_tpu:
def tpu_scaffold():
tf.train.init_from_checkpoint(init_checkpoint, assignment_map)
return tf.train.Scaffold()
scaffold_fn = tpu_scaffold
else:
tf.train.init_from_checkpoint(init_checkpoint, assignment_map)
tf.logging.info("**** Trainable Variables ****")
for var in tvars:
init_string = ""
if var.name in initialized_variable_names:
init_string = ", *INIT_FROM_CKPT*"
tf.logging.info(" name = %s, shape = %s%s", var.name, var.shape,
init_string)
all_layers = model.get_all_encoder_layers()
predictions = {
"unique_id": unique_ids,
}
for (i, layer_index) in enumerate(layer_indexes):
predictions["layer_output_%d" % i] = all_layers[layer_index]
output_spec = tf.contrib.tpu.TPUEstimatorSpec(
mode=mode, predictions=predictions, scaffold_fn=scaffold_fn)
return output_spec
return model_fn
def convert_examples_to_features(examples, seq_length, tokenizer):
"""Loads a data file into a list of `InputBatch`s."""
features = []
for (ex_index, example) in enumerate(examples):
tokens_a = tokenizer.tokenize(example.text_a)
tokens_b = None
if example.text_b:
tokens_b = tokenizer.tokenize(example.text_b)
if tokens_b:
# Modifies `tokens_a` and `tokens_b` in place so that the total
# length is less than the specified length.
# Account for [CLS], [SEP], [SEP] with "- 3"
_truncate_seq_pair(tokens_a, tokens_b, seq_length - 3)
else:
# Account for [CLS] and [SEP] with "- 2"
if len(tokens_a) > seq_length - 2:
tokens_a = tokens_a[0:(seq_length - 2)]
# The convention in BERT is:
# (a) For sequence pairs:
# tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
# type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1
# (b) For single sequences:
# tokens: [CLS] the dog is hairy . [SEP]
# type_ids: 0 0 0 0 0 0 0
#
# Where "type_ids" are used to indicate whether this is the first
# sequence or the second sequence. The embedding vectors for `type=0` and
# `type=1` were learned during pre-training and are added to the wordpiece
# embedding vector (and position vector). This is not *strictly* necessary
# since the [SEP] token unambiguously separates the sequences, but it makes
# it easier for the model to learn the concept of sequences.
#
# For classification tasks, the first vector (corresponding to [CLS]) is
# used as as the "sentence vector". Note that this only makes sense because
# the entire model is fine-tuned.
tokens = []
input_type_ids = []
tokens.append("[CLS]")
input_type_ids.append(0)
for token in tokens_a:
tokens.append(token)
input_type_ids.append(0)
tokens.append("[SEP]")
input_type_ids.append(0)
if tokens_b:
for token in tokens_b:
tokens.append(token)
input_type_ids.append(1)
tokens.append("[SEP]")
input_type_ids.append(1)
input_ids = tokenizer.convert_tokens_to_ids(tokens)
# The mask has 1 for real tokens and 0 for padding tokens. Only real
# tokens are attended to.
input_mask = [1] * len(input_ids)
# Zero-pad up to the sequence length.
while len(input_ids) < seq_length:
input_ids.append(0)
input_mask.append(0)
input_type_ids.append(0)
assert len(input_ids) == seq_length
assert len(input_mask) == seq_length
assert len(input_type_ids) == seq_length
if ex_index < 5:
tf.logging.info("*** Example ***")
tf.logging.info("unique_id: %s" % (example.unique_id))
tf.logging.info("tokens: %s" % " ".join(
[tokenization.printable_text(x) for x in tokens]))
tf.logging.info("input_ids: %s" % " ".join([str(x) for x in input_ids]))
tf.logging.info("input_mask: %s" % " ".join([str(x) for x in input_mask]))
tf.logging.info(
"input_type_ids: %s" % " ".join([str(x) for x in input_type_ids]))
features.append(
InputFeatures(
unique_id=example.unique_id,
tokens=tokens,
input_ids=input_ids,
input_mask=input_mask,
input_type_ids=input_type_ids))
return features
def _truncate_seq_pair(tokens_a, tokens_b, max_length):
"""Truncates a sequence pair in place to the maximum length."""
# This is a simple heuristic which will always truncate the longer sequence
# one token at a time. This makes more sense than truncating an equal percent
# of tokens from each, since if one sequence is very short then each token
# that's truncated likely contains more information than a longer sequence.
while True:
total_length = len(tokens_a) + len(tokens_b)
if total_length <= max_length:
break
if len(tokens_a) > len(tokens_b):
tokens_a.pop()
else:
tokens_b.pop()
def read_examples(input_file):
"""Read a list of `InputExample`s from an input file."""
examples = []
unique_id = 0
with tf.gfile.GFile(input_file, "r") as reader:
while True:
line = tokenization.convert_to_unicode(reader.readline())
if not line:
break
line = line.strip()
text_a = None
text_b = None
m = re.match(r"^(.*) \|\|\| (.*)$", line)
if m is None:
text_a = line
else:
text_a = m.group(1)
text_b = m.group(2)
examples.append(
InputExample(unique_id=unique_id, text_a=text_a, text_b=text_b))
unique_id += 1
return examples
def main(_):
tf.logging.set_verbosity(tf.logging.INFO)
layer_indexes = [int(x) for x in FLAGS.layers.split(",")]
bert_config = modeling.BertConfig.from_json_file(FLAGS.bert_config_file)
tokenizer = tokenization.FullTokenizer(
vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)
is_per_host = tf.contrib.tpu.InputPipelineConfig.PER_HOST_V2
run_config = tf.contrib.tpu.RunConfig(
master=FLAGS.master,
tpu_config=tf.contrib.tpu.TPUConfig(
num_shards=FLAGS.num_tpu_cores,
per_host_input_for_training=is_per_host))
examples = read_examples(FLAGS.input_file)
features = convert_examples_to_features(
examples=examples, seq_length=FLAGS.max_seq_length, tokenizer=tokenizer)
unique_id_to_feature = {}
for feature in features:
unique_id_to_feature[feature.unique_id] = feature
model_fn = model_fn_builder(
bert_config=bert_config,
init_checkpoint=FLAGS.init_checkpoint,
layer_indexes=layer_indexes,
use_tpu=FLAGS.use_tpu,
use_one_hot_embeddings=FLAGS.use_one_hot_embeddings)
# If TPU is not available, this will fall back to normal Estimator on CPU
# or GPU.
estimator = tf.contrib.tpu.TPUEstimator(
use_tpu=FLAGS.use_tpu,
model_fn=model_fn,
config=run_config,
predict_batch_size=FLAGS.batch_size)
input_fn = input_fn_builder(
features=features, seq_length=FLAGS.max_seq_length)
with codecs.getwriter("utf-8")(tf.gfile.Open(FLAGS.output_file,
"w")) as writer:
for result in estimator.predict(input_fn, yield_single_examples=True):
unique_id = int(result["unique_id"])
feature = unique_id_to_feature[unique_id]
output_json = collections.OrderedDict()
output_json["linex_index"] = unique_id
all_features = []
for (i, token) in enumerate(feature.tokens):
all_layers = []
for (j, layer_index) in enumerate(layer_indexes):
layer_output = result["layer_output_%d" % j]
layers = collections.OrderedDict()
layers["index"] = layer_index
layers["values"] = [
round(float(x), 6) for x in layer_output[i:(i + 1)].flat
]
all_layers.append(layers)
features = collections.OrderedDict()
features["token"] = token
features["layers"] = all_layers
all_features.append(features)
output_json["features"] = all_features
writer.write(json.dumps(output_json) + "\n")
if __name__ == "__main__":
flags.mark_flag_as_required("input_file")
flags.mark_flag_as_required("vocab_file")
flags.mark_flag_as_required("bert_config_file")
flags.mark_flag_as_required("init_checkpoint")
flags.mark_flag_as_required("output_file")
tf.app.run()
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import optimization
import tensorflow as tf
class OptimizationTest(tf.test.TestCase):
def test_adam(self):
with self.test_session() as sess:
w = tf.get_variable(
"w",
shape=[3],
initializer=tf.constant_initializer([0.1, -0.2, -0.1]))
x = tf.constant([0.4, 0.2, -0.5])
loss = tf.reduce_mean(tf.square(x - w))
tvars = tf.trainable_variables()
grads = tf.gradients(loss, tvars)
global_step = tf.train.get_or_create_global_step()
optimizer = optimization.AdamWeightDecayOptimizer(learning_rate=0.2)
train_op = optimizer.apply_gradients(zip(grads, tvars), global_step)
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
for _ in range(100):
sess.run(train_op)
w_np = sess.run(w)
self.assertAllClose(w_np.flat, [0.4, 0.2, -0.5], rtol=1e-2, atol=1e-2)
if __name__ == "__main__":
tf.test.main()
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Functions and classes related to optimization (weight updates)."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import re
import tensorflow as tf
def create_optimizer(loss, init_lr, num_train_steps, num_warmup_steps, use_tpu):
"""Creates an optimizer training op."""
global_step = tf.train.get_or_create_global_step()
learning_rate = tf.constant(value=init_lr, shape=[], dtype=tf.float32)
# Implements linear decay of the learning rate.
learning_rate = tf.train.polynomial_decay(
learning_rate,
global_step,
num_train_steps,
end_learning_rate=0.0,
power=1.0,
cycle=False)
# Implements linear warmup. I.e., if global_step < num_warmup_steps, the
# learning rate will be `global_step/num_warmup_steps * init_lr`.
if num_warmup_steps:
global_steps_int = tf.cast(global_step, tf.int32)
warmup_steps_int = tf.constant(num_warmup_steps, dtype=tf.int32)
global_steps_float = tf.cast(global_steps_int, tf.float32)
warmup_steps_float = tf.cast(warmup_steps_int, tf.float32)
warmup_percent_done = global_steps_float / warmup_steps_float
warmup_learning_rate = init_lr * warmup_percent_done
is_warmup = tf.cast(global_steps_int < warmup_steps_int, tf.float32)
learning_rate = (
(1.0 - is_warmup) * learning_rate + is_warmup * warmup_learning_rate)
# It is recommended that you use this optimizer for fine tuning, since this
# is how the model was trained (note that the Adam m/v variables are NOT
# loaded from init_checkpoint.)
optimizer = AdamWeightDecayOptimizer(
learning_rate=learning_rate,
weight_decay_rate=0.01,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-6,
exclude_from_weight_decay=["LayerNorm", "layer_norm", "bias"])
if use_tpu:
optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer)
tvars = tf.trainable_variables()
grads = tf.gradients(loss, tvars)
# This is how the model was pre-trained.
(grads, _) = tf.clip_by_global_norm(grads, clip_norm=1.0)
train_op = optimizer.apply_gradients(
zip(grads, tvars), global_step=global_step)
# Normally the global step update is done inside of `apply_gradients`.
# However, `AdamWeightDecayOptimizer` doesn't do this. But if you use
# a different optimizer, you should probably take this line out.
new_global_step = global_step + 1
train_op = tf.group(train_op, [global_step.assign(new_global_step)])
return train_op
class AdamWeightDecayOptimizer(tf.train.Optimizer):
"""A basic Adam optimizer that includes "correct" L2 weight decay."""
def __init__(self,
learning_rate,
weight_decay_rate=0.0,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-6,
exclude_from_weight_decay=None,
name="AdamWeightDecayOptimizer"):
"""Constructs a AdamWeightDecayOptimizer."""
super(AdamWeightDecayOptimizer, self).__init__(False, name)
self.learning_rate = learning_rate
self.weight_decay_rate = weight_decay_rate
self.beta_1 = beta_1
self.beta_2 = beta_2
self.epsilon = epsilon
self.exclude_from_weight_decay = exclude_from_weight_decay
def apply_gradients(self, grads_and_vars, global_step=None, name=None):
"""See base class."""
assignments = []
for (grad, param) in grads_and_vars:
if grad is None or param is None:
continue
param_name = self._get_variable_name(param.name)
m = tf.get_variable(
name=param_name + "/adam_m",
shape=param.shape.as_list(),
dtype=tf.float32,
trainable=False,
initializer=tf.zeros_initializer())
v = tf.get_variable(
name=param_name + "/adam_v",
shape=param.shape.as_list(),
dtype=tf.float32,
trainable=False,
initializer=tf.zeros_initializer())
# Standard Adam update.
next_m = (
tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))
next_v = (
tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,
tf.square(grad)))
update = next_m / (tf.sqrt(next_v) + self.epsilon)
# Just adding the square of the weights to the loss function is *not*
# the correct way of using L2 regularization/weight decay with Adam,
# since that will interact with the m and v parameters in strange ways.
#
# Instead we want ot decay the weights in a manner that doesn't interact
# with the m/v parameters. This is equivalent to adding the square
# of the weights to the loss with plain (non-momentum) SGD.
if self._do_use_weight_decay(param_name):
update += self.weight_decay_rate * param
update_with_lr = self.learning_rate * update
next_param = param - update_with_lr
assignments.extend(
[param.assign(next_param),
m.assign(next_m),
v.assign(next_v)])
return tf.group(*assignments, name=name)
def _do_use_weight_decay(self, param_name):
"""Whether to use L2 weight decay for `param_name`."""
if not self.weight_decay_rate:
return False
if self.exclude_from_weight_decay:
for r in self.exclude_from_weight_decay:
if re.search(r, param_name) is not None:
return False
return True
def _get_variable_name(self, param_name):
"""Get the variable name from the tensor name."""
m = re.match("^(.*):\\d+$", param_name)
if m is not None:
param_name = m.group(1)
return param_name
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import tempfile
import tokenization
import six
import tensorflow as tf
class TokenizationTest(tf.test.TestCase):
def test_full_tokenizer(self):
vocab_tokens = [
"[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn",
"##ing", ","
]
with tempfile.NamedTemporaryFile(delete=False) as vocab_writer:
if six.PY2:
vocab_writer.write("".join([x + "\n" for x in vocab_tokens]))
else:
vocab_writer.write("".join(
[x + "\n" for x in vocab_tokens]).encode("utf-8"))
vocab_file = vocab_writer.name
tokenizer = tokenization.FullTokenizer(vocab_file)
os.unlink(vocab_file)
tokens = tokenizer.tokenize(u"UNwant\u00E9d,running")
self.assertAllEqual(tokens, ["un", "##want", "##ed", ",", "runn", "##ing"])
self.assertAllEqual(
tokenizer.convert_tokens_to_ids(tokens), [7, 4, 5, 10, 8, 9])
def test_chinese(self):
tokenizer = tokenization.BasicTokenizer()
self.assertAllEqual(
tokenizer.tokenize(u"ah\u535A\u63A8zz"),
[u"ah", u"\u535A", u"\u63A8", u"zz"])
def test_basic_tokenizer_lower(self):
tokenizer = tokenization.BasicTokenizer(do_lower_case=True)
self.assertAllEqual(
tokenizer.tokenize(u" \tHeLLo!how \n Are yoU? "),
["hello", "!", "how", "are", "you", "?"])
self.assertAllEqual(tokenizer.tokenize(u"H\u00E9llo"), ["hello"])
def test_basic_tokenizer_no_lower(self):
tokenizer = tokenization.BasicTokenizer(do_lower_case=False)
self.assertAllEqual(
tokenizer.tokenize(u" \tHeLLo!how \n Are yoU? "),
["HeLLo", "!", "how", "Are", "yoU", "?"])
def test_wordpiece_tokenizer(self):
vocab_tokens = [
"[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn",
"##ing"
]
vocab = {}
for (i, token) in enumerate(vocab_tokens):
vocab[token] = i
tokenizer = tokenization.WordpieceTokenizer(vocab=vocab)
self.assertAllEqual(tokenizer.tokenize(""), [])
self.assertAllEqual(
tokenizer.tokenize("unwanted running"),
["un", "##want", "##ed", "runn", "##ing"])
self.assertAllEqual(
tokenizer.tokenize("unwantedX running"), ["[UNK]", "runn", "##ing"])
def test_convert_tokens_to_ids(self):
vocab_tokens = [
"[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn",
"##ing"
]
vocab = {}
for (i, token) in enumerate(vocab_tokens):
vocab[token] = i
self.assertAllEqual(
tokenization.convert_tokens_to_ids(
vocab, ["un", "##want", "##ed", "runn", "##ing"]), [7, 4, 5, 8, 9])
def test_is_whitespace(self):
self.assertTrue(tokenization._is_whitespace(u" "))
self.assertTrue(tokenization._is_whitespace(u"\t"))
self.assertTrue(tokenization._is_whitespace(u"\r"))
self.assertTrue(tokenization._is_whitespace(u"\n"))
self.assertTrue(tokenization._is_whitespace(u"\u00A0"))
self.assertFalse(tokenization._is_whitespace(u"A"))
self.assertFalse(tokenization._is_whitespace(u"-"))
def test_is_control(self):
self.assertTrue(tokenization._is_control(u"\u0005"))
self.assertFalse(tokenization._is_control(u"A"))
self.assertFalse(tokenization._is_control(u" "))
self.assertFalse(tokenization._is_control(u"\t"))
self.assertFalse(tokenization._is_control(u"\r"))
self.assertFalse(tokenization._is_control(u"\U0001F4A9"))
def test_is_punctuation(self):
self.assertTrue(tokenization._is_punctuation(u"-"))
self.assertTrue(tokenization._is_punctuation(u"$"))
self.assertTrue(tokenization._is_punctuation(u"`"))
self.assertTrue(tokenization._is_punctuation(u"."))
self.assertFalse(tokenization._is_punctuation(u"A"))
self.assertFalse(tokenization._is_punctuation(u" "))
if __name__ == "__main__":
tf.test.main()
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Run BERT on SQuAD 1.1 and SQuAD 2.0."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import json
import math
import os
import random
import modeling
import optimization
import tokenization
import six
import tensorflow as tf
flags = tf.flags
FLAGS = flags.FLAGS
## Required parameters
flags.DEFINE_string(
"bert_config_file", None,
"The config json file corresponding to the pre-trained BERT model. "
"This specifies the model architecture.")
flags.DEFINE_string("vocab_file", None,
"The vocabulary file that the BERT model was trained on.")
flags.DEFINE_string(
"output_dir", None,
"The output directory where the model checkpoints will be written.")
## Other parameters
flags.DEFINE_string("train_file", None,
"SQuAD json for training. E.g., train-v1.1.json")
flags.DEFINE_string(
"predict_file", None,
"SQuAD json for predictions. E.g., dev-v1.1.json or test-v1.1.json")
flags.DEFINE_string(
"init_checkpoint", None,
"Initial checkpoint (usually from a pre-trained BERT model).")
flags.DEFINE_bool(
"do_lower_case", True,
"Whether to lower case the input text. Should be True for uncased "
"models and False for cased models.")
flags.DEFINE_integer(
"max_seq_length", 384,
"The maximum total input sequence length after WordPiece tokenization. "
"Sequences longer than this will be truncated, and sequences shorter "
"than this will be padded.")
flags.DEFINE_integer(
"doc_stride", 128,
"When splitting up a long document into chunks, how much stride to "
"take between chunks.")
flags.DEFINE_integer(
"max_query_length", 64,
"The maximum number of tokens for the question. Questions longer than "
"this will be truncated to this length.")
flags.DEFINE_bool("do_train", False, "Whether to run training.")
flags.DEFINE_bool("do_predict", False, "Whether to run eval on the dev set.")
flags.DEFINE_integer("train_batch_size", 32, "Total batch size for training.")
flags.DEFINE_integer("predict_batch_size", 8,
"Total batch size for predictions.")
flags.DEFINE_float("learning_rate", 5e-5, "The initial learning rate for Adam.")
flags.DEFINE_float("num_train_epochs", 3.0,
"Total number of training epochs to perform.")
flags.DEFINE_float(
"warmup_proportion", 0.1,
"Proportion of training to perform linear learning rate warmup for. "
"E.g., 0.1 = 10% of training.")
flags.DEFINE_integer("save_checkpoints_steps", 1000,
"How often to save the model checkpoint.")
flags.DEFINE_integer("iterations_per_loop", 1000,
"How many steps to make in each estimator call.")
flags.DEFINE_integer(
"n_best_size", 20,
"The total number of n-best predictions to generate in the "
"nbest_predictions.json output file.")
flags.DEFINE_integer(
"max_answer_length", 30,
"The maximum length of an answer that can be generated. This is needed "
"because the start and end predictions are not conditioned on one another.")
flags.DEFINE_bool("use_tpu", False, "Whether to use TPU or GPU/CPU.")
tf.flags.DEFINE_string(
"tpu_name", None,
"The Cloud TPU to use for training. This should be either the name "
"used when creating the Cloud TPU, or a grpc://ip.address.of.tpu:8470 "
"url.")
tf.flags.DEFINE_string(
"tpu_zone", None,
"[Optional] GCE zone where the Cloud TPU is located in. If not "
"specified, we will attempt to automatically detect the GCE project from "
"metadata.")
tf.flags.DEFINE_string(
"gcp_project", None,
"[Optional] Project name for the Cloud TPU-enabled project. If not "
"specified, we will attempt to automatically detect the GCE project from "
"metadata.")
tf.flags.DEFINE_string("master", None, "[Optional] TensorFlow master URL.")
flags.DEFINE_integer(
"num_tpu_cores", 8,
"Only used if `use_tpu` is True. Total number of TPU cores to use.")
flags.DEFINE_bool(
"verbose_logging", False,
"If true, all of the warnings related to data processing will be printed. "
"A number of warnings are expected for a normal SQuAD evaluation.")
flags.DEFINE_bool(
"version_2_with_negative", False,
"If true, the SQuAD examples contain some that do not have an answer.")
flags.DEFINE_float(
"null_score_diff_threshold", 0.0,
"If null_score - best_non_null is greater than the threshold predict null.")
class SquadExample(object):
"""A single training/test example for simple sequence classification.
For examples without an answer, the start and end position are -1.
"""
def __init__(self,
qas_id,
question_text,
doc_tokens,
orig_answer_text=None,
start_position=None,
end_position=None,
is_impossible=False):
self.qas_id = qas_id
self.question_text = question_text
self.doc_tokens = doc_tokens
self.orig_answer_text = orig_answer_text
self.start_position = start_position
self.end_position = end_position
self.is_impossible = is_impossible
def __str__(self):
return self.__repr__()
def __repr__(self):
s = ""
s += "qas_id: %s" % (tokenization.printable_text(self.qas_id))
s += ", question_text: %s" % (
tokenization.printable_text(self.question_text))
s += ", doc_tokens: [%s]" % (" ".join(self.doc_tokens))
if self.start_position:
s += ", start_position: %d" % (self.start_position)
if self.start_position:
s += ", end_position: %d" % (self.end_position)
if self.start_position:
s += ", is_impossible: %r" % (self.is_impossible)
return s
class InputFeatures(object):
"""A single set of features of data."""
def __init__(self,
unique_id,
example_index,
doc_span_index,
tokens,
token_to_orig_map,
token_is_max_context,
input_ids,
input_mask,
segment_ids,
start_position=None,
end_position=None,
is_impossible=None):
self.unique_id = unique_id
self.example_index = example_index
self.doc_span_index = doc_span_index
self.tokens = tokens
self.token_to_orig_map = token_to_orig_map
self.token_is_max_context = token_is_max_context
self.input_ids = input_ids
self.input_mask = input_mask
self.segment_ids = segment_ids
self.start_position = start_position
self.end_position = end_position
self.is_impossible = is_impossible
def read_squad_examples(input_file, is_training):
"""Read a SQuAD json file into a list of SquadExample."""
with tf.gfile.Open(input_file, "r") as reader:
input_data = json.load(reader)["data"]
def is_whitespace(c):
if c == " " or c == "\t" or c == "\r" or c == "\n" or ord(c) == 0x202F:
return True
return False
examples = []
for entry in input_data:
for paragraph in entry["paragraphs"]:
paragraph_text = paragraph["context"]
doc_tokens = []
char_to_word_offset = []
prev_is_whitespace = True
for c in paragraph_text:
if is_whitespace(c):
prev_is_whitespace = True
else:
if prev_is_whitespace:
doc_tokens.append(c)
else:
doc_tokens[-1] += c
prev_is_whitespace = False
char_to_word_offset.append(len(doc_tokens) - 1)
for qa in paragraph["qas"]:
qas_id = qa["id"]
question_text = qa["question"]
start_position = None
end_position = None
orig_answer_text = None
is_impossible = False
if is_training:
if FLAGS.version_2_with_negative:
is_impossible = qa["is_impossible"]
if (len(qa["answers"]) != 1) and (not is_impossible):
raise ValueError(
"For training, each question should have exactly 1 answer.")
if not is_impossible:
answer = qa["answers"][0]
orig_answer_text = answer["text"]
answer_offset = answer["answer_start"]
answer_length = len(orig_answer_text)
start_position = char_to_word_offset[answer_offset]
end_position = char_to_word_offset[answer_offset + answer_length -
1]
# Only add answers where the text can be exactly recovered from the
# document. If this CAN'T happen it's likely due to weird Unicode
# stuff so we will just skip the example.
#
# Note that this means for training mode, every example is NOT
# guaranteed to be preserved.
actual_text = " ".join(
doc_tokens[start_position:(end_position + 1)])
cleaned_answer_text = " ".join(
tokenization.whitespace_tokenize(orig_answer_text))
if actual_text.find(cleaned_answer_text) == -1:
tf.logging.warning("Could not find answer: '%s' vs. '%s'",
actual_text, cleaned_answer_text)
continue
else:
start_position = -1
end_position = -1
orig_answer_text = ""
example = SquadExample(
qas_id=qas_id,
question_text=question_text,
doc_tokens=doc_tokens,
orig_answer_text=orig_answer_text,
start_position=start_position,
end_position=end_position,
is_impossible=is_impossible)
examples.append(example)
return examples
def convert_examples_to_features(examples, tokenizer, max_seq_length,
doc_stride, max_query_length, is_training,
output_fn):
"""Loads a data file into a list of `InputBatch`s."""
unique_id = 1000000000
for (example_index, example) in enumerate(examples):
query_tokens = tokenizer.tokenize(example.question_text)
if len(query_tokens) > max_query_length:
query_tokens = query_tokens[0:max_query_length]
tok_to_orig_index = []
orig_to_tok_index = []
all_doc_tokens = []
for (i, token) in enumerate(example.doc_tokens):
orig_to_tok_index.append(len(all_doc_tokens))
sub_tokens = tokenizer.tokenize(token)
for sub_token in sub_tokens:
tok_to_orig_index.append(i)
all_doc_tokens.append(sub_token)
tok_start_position = None
tok_end_position = None
if is_training and example.is_impossible:
tok_start_position = -1
tok_end_position = -1
if is_training and not example.is_impossible:
tok_start_position = orig_to_tok_index[example.start_position]
if example.end_position < len(example.doc_tokens) - 1:
tok_end_position = orig_to_tok_index[example.end_position + 1] - 1
else:
tok_end_position = len(all_doc_tokens) - 1
(tok_start_position, tok_end_position) = _improve_answer_span(
all_doc_tokens, tok_start_position, tok_end_position, tokenizer,
example.orig_answer_text)
# The -3 accounts for [CLS], [SEP] and [SEP]
max_tokens_for_doc = max_seq_length - len(query_tokens) - 3
# We can have documents that are longer than the maximum sequence length.
# To deal with this we do a sliding window approach, where we take chunks
# of the up to our max length with a stride of `doc_stride`.
_DocSpan = collections.namedtuple( # pylint: disable=invalid-name
"DocSpan", ["start", "length"])
doc_spans = []
start_offset = 0
while start_offset < len(all_doc_tokens):
length = len(all_doc_tokens) - start_offset
if length > max_tokens_for_doc:
length = max_tokens_for_doc
doc_spans.append(_DocSpan(start=start_offset, length=length))
if start_offset + length == len(all_doc_tokens):
break
start_offset += min(length, doc_stride)
for (doc_span_index, doc_span) in enumerate(doc_spans):
tokens = []
token_to_orig_map = {}
token_is_max_context = {}
segment_ids = []
tokens.append("[CLS]")
segment_ids.append(0)
for token in query_tokens:
tokens.append(token)
segment_ids.append(0)
tokens.append("[SEP]")
segment_ids.append(0)
for i in range(doc_span.length):
split_token_index = doc_span.start + i
token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]
is_max_context = _check_is_max_context(doc_spans, doc_span_index,
split_token_index)
token_is_max_context[len(tokens)] = is_max_context
tokens.append(all_doc_tokens[split_token_index])
segment_ids.append(1)
tokens.append("[SEP]")
segment_ids.append(1)
input_ids = tokenizer.convert_tokens_to_ids(tokens)
# The mask has 1 for real tokens and 0 for padding tokens. Only real
# tokens are attended to.
input_mask = [1] * len(input_ids)
# Zero-pad up to the sequence length.
while len(input_ids) < max_seq_length:
input_ids.append(0)
input_mask.append(0)
segment_ids.append(0)
assert len(input_ids) == max_seq_length
assert len(input_mask) == max_seq_length
assert len(segment_ids) == max_seq_length
start_position = None
end_position = None
if is_training and not example.is_impossible:
# For training, if our document chunk does not contain an annotation
# we throw it out, since there is nothing to predict.
doc_start = doc_span.start
doc_end = doc_span.start + doc_span.length - 1
out_of_span = False
if not (tok_start_position >= doc_start and
tok_end_position <= doc_end):
out_of_span = True
if out_of_span:
start_position = 0
end_position = 0
else:
doc_offset = len(query_tokens) + 2
start_position = tok_start_position - doc_start + doc_offset
end_position = tok_end_position - doc_start + doc_offset
if is_training and example.is_impossible:
start_position = 0
end_position = 0
if example_index < 20:
tf.logging.info("*** Example ***")
tf.logging.info("unique_id: %s" % (unique_id))
tf.logging.info("example_index: %s" % (example_index))
tf.logging.info("doc_span_index: %s" % (doc_span_index))
tf.logging.info("tokens: %s" % " ".join(
[tokenization.printable_text(x) for x in tokens]))
tf.logging.info("token_to_orig_map: %s" % " ".join(
["%d:%d" % (x, y) for (x, y) in six.iteritems(token_to_orig_map)]))
tf.logging.info("token_is_max_context: %s" % " ".join([
"%d:%s" % (x, y) for (x, y) in six.iteritems(token_is_max_context)
]))
tf.logging.info("input_ids: %s" % " ".join([str(x) for x in input_ids]))
tf.logging.info(
"input_mask: %s" % " ".join([str(x) for x in input_mask]))
tf.logging.info(
"segment_ids: %s" % " ".join([str(x) for x in segment_ids]))
if is_training and example.is_impossible:
tf.logging.info("impossible example")
if is_training and not example.is_impossible:
answer_text = " ".join(tokens[start_position:(end_position + 1)])
tf.logging.info("start_position: %d" % (start_position))
tf.logging.info("end_position: %d" % (end_position))
tf.logging.info(
"answer: %s" % (tokenization.printable_text(answer_text)))
feature = InputFeatures(
unique_id=unique_id,
example_index=example_index,
doc_span_index=doc_span_index,
tokens=tokens,
token_to_orig_map=token_to_orig_map,
token_is_max_context=token_is_max_context,
input_ids=input_ids,
input_mask=input_mask,
segment_ids=segment_ids,
start_position=start_position,
end_position=end_position,
is_impossible=example.is_impossible)
# Run callback
output_fn(feature)
unique_id += 1
def _improve_answer_span(doc_tokens, input_start, input_end, tokenizer,
orig_answer_text):
"""Returns tokenized answer spans that better match the annotated answer."""
# The SQuAD annotations are character based. We first project them to
# whitespace-tokenized words. But then after WordPiece tokenization, we can
# often find a "better match". For example:
#
# Question: What year was John Smith born?
# Context: The leader was John Smith (1895-1943).
# Answer: 1895
#
# The original whitespace-tokenized answer will be "(1895-1943).". However
# after tokenization, our tokens will be "( 1895 - 1943 ) .". So we can match
# the exact answer, 1895.
#
# However, this is not always possible. Consider the following:
#
# Question: What country is the top exporter of electornics?
# Context: The Japanese electronics industry is the lagest in the world.
# Answer: Japan
#
# In this case, the annotator chose "Japan" as a character sub-span of
# the word "Japanese". Since our WordPiece tokenizer does not split
# "Japanese", we just use "Japanese" as the annotation. This is fairly rare
# in SQuAD, but does happen.
tok_answer_text = " ".join(tokenizer.tokenize(orig_answer_text))
for new_start in range(input_start, input_end + 1):
for new_end in range(input_end, new_start - 1, -1):
text_span = " ".join(doc_tokens[new_start:(new_end + 1)])
if text_span == tok_answer_text:
return (new_start, new_end)
return (input_start, input_end)
def _check_is_max_context(doc_spans, cur_span_index, position):
"""Check if this is the 'max context' doc span for the token."""
# Because of the sliding window approach taken to scoring documents, a single
# token can appear in multiple documents. E.g.
# Doc: the man went to the store and bought a gallon of milk
# Span A: the man went to the
# Span B: to the store and bought
# Span C: and bought a gallon of
# ...
#
# Now the word 'bought' will have two scores from spans B and C. We only
# want to consider the score with "maximum context", which we define as
# the *minimum* of its left and right context (the *sum* of left and
# right context will always be the same, of course).
#
# In the example the maximum context for 'bought' would be span C since
# it has 1 left context and 3 right context, while span B has 4 left context
# and 0 right context.
best_score = None
best_span_index = None
for (span_index, doc_span) in enumerate(doc_spans):
end = doc_span.start + doc_span.length - 1
if position < doc_span.start:
continue
if position > end:
continue
num_left_context = position - doc_span.start
num_right_context = end - position
score = min(num_left_context, num_right_context) + 0.01 * doc_span.length
if best_score is None or score > best_score:
best_score = score
best_span_index = span_index
return cur_span_index == best_span_index
def create_model(bert_config, is_training, input_ids, input_mask, segment_ids,
use_one_hot_embeddings):
"""Creates a classification model."""
model = modeling.BertModel(
config=bert_config,
is_training=is_training,
input_ids=input_ids,
input_mask=input_mask,
token_type_ids=segment_ids,
use_one_hot_embeddings=use_one_hot_embeddings)
final_hidden = model.get_sequence_output()
final_hidden_shape = modeling.get_shape_list(final_hidden, expected_rank=3)
batch_size = final_hidden_shape[0]
seq_length = final_hidden_shape[1]
hidden_size = final_hidden_shape[2]
output_weights = tf.get_variable(
"cls/squad/output_weights", [2, hidden_size],
initializer=tf.truncated_normal_initializer(stddev=0.02))
output_bias = tf.get_variable(
"cls/squad/output_bias", [2], initializer=tf.zeros_initializer())
final_hidden_matrix = tf.reshape(final_hidden,
[batch_size * seq_length, hidden_size])
logits = tf.matmul(final_hidden_matrix, output_weights, transpose_b=True)
logits = tf.nn.bias_add(logits, output_bias)
logits = tf.reshape(logits, [batch_size, seq_length, 2])
logits = tf.transpose(logits, [2, 0, 1])
unstacked_logits = tf.unstack(logits, axis=0)
(start_logits, end_logits) = (unstacked_logits[0], unstacked_logits[1])
return (start_logits, end_logits)
def model_fn_builder(bert_config, init_checkpoint, learning_rate,
num_train_steps, num_warmup_steps, use_tpu,
use_one_hot_embeddings):
"""Returns `model_fn` closure for TPUEstimator."""
def model_fn(features, labels, mode, params): # pylint: disable=unused-argument
"""The `model_fn` for TPUEstimator."""
tf.logging.info("*** Features ***")
for name in sorted(features.keys()):
tf.logging.info(" name = %s, shape = %s" % (name, features[name].shape))
unique_ids = features["unique_ids"]
input_ids = features["input_ids"]
input_mask = features["input_mask"]
segment_ids = features["segment_ids"]
is_training = (mode == tf.estimator.ModeKeys.TRAIN)
(start_logits, end_logits) = create_model(
bert_config=bert_config,
is_training=is_training,
input_ids=input_ids,
input_mask=input_mask,
segment_ids=segment_ids,
use_one_hot_embeddings=use_one_hot_embeddings)
tvars = tf.trainable_variables()
initialized_variable_names = {}
scaffold_fn = None
if init_checkpoint:
(assignment_map, initialized_variable_names
) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)
if use_tpu:
def tpu_scaffold():
tf.train.init_from_checkpoint(init_checkpoint, assignment_map)
return tf.train.Scaffold()
scaffold_fn = tpu_scaffold
else:
tf.train.init_from_checkpoint(init_checkpoint, assignment_map)
tf.logging.info("**** Trainable Variables ****")
for var in tvars:
init_string = ""
if var.name in initialized_variable_names:
init_string = ", *INIT_FROM_CKPT*"
tf.logging.info(" name = %s, shape = %s%s", var.name, var.shape,
init_string)
output_spec = None
if mode == tf.estimator.ModeKeys.TRAIN:
seq_length = modeling.get_shape_list(input_ids)[1]
def compute_loss(logits, positions):
one_hot_positions = tf.one_hot(
positions, depth=seq_length, dtype=tf.float32)
log_probs = tf.nn.log_softmax(logits, axis=-1)
loss = -tf.reduce_mean(
tf.reduce_sum(one_hot_positions * log_probs, axis=-1))
return loss
start_positions = features["start_positions"]
end_positions = features["end_positions"]
start_loss = compute_loss(start_logits, start_positions)
end_loss = compute_loss(end_logits, end_positions)
total_loss = (start_loss + end_loss) / 2.0
train_op = optimization.create_optimizer(
total_loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu)
output_spec = tf.contrib.tpu.TPUEstimatorSpec(
mode=mode,
loss=total_loss,
train_op=train_op,
scaffold_fn=scaffold_fn)
elif mode == tf.estimator.ModeKeys.PREDICT:
predictions = {
"unique_ids": unique_ids,
"start_logits": start_logits,
"end_logits": end_logits,
}
output_spec = tf.contrib.tpu.TPUEstimatorSpec(
mode=mode, predictions=predictions, scaffold_fn=scaffold_fn)
else:
raise ValueError(
"Only TRAIN and PREDICT modes are supported: %s" % (mode))
return output_spec
return model_fn
def input_fn_builder(input_file, seq_length, is_training, drop_remainder):
"""Creates an `input_fn` closure to be passed to TPUEstimator."""
name_to_features = {
"unique_ids": tf.FixedLenFeature([], tf.int64),
"input_ids": tf.FixedLenFeature([seq_length], tf.int64),
"input_mask": tf.FixedLenFeature([seq_length], tf.int64),
"segment_ids": tf.FixedLenFeature([seq_length], tf.int64),
}
if is_training:
name_to_features["start_positions"] = tf.FixedLenFeature([], tf.int64)
name_to_features["end_positions"] = tf.FixedLenFeature([], tf.int64)
def _decode_record(record, name_to_features):
"""Decodes a record to a TensorFlow example."""
example = tf.parse_single_example(record, name_to_features)
# tf.Example only supports tf.int64, but the TPU only supports tf.int32.
# So cast all int64 to int32.
for name in list(example.keys()):
t = example[name]
if t.dtype == tf.int64:
t = tf.to_int32(t)
example[name] = t
return example
def input_fn(params):
"""The actual input function."""
batch_size = params["batch_size"]
# For training, we want a lot of parallel reading and shuffling.
# For eval, we want no shuffling and parallel reading doesn't matter.
d = tf.data.TFRecordDataset(input_file)
if is_training:
d = d.repeat()
d = d.shuffle(buffer_size=100)
d = d.apply(
tf.contrib.data.map_and_batch(
lambda record: _decode_record(record, name_to_features),
batch_size=batch_size,
drop_remainder=drop_remainder))
return d
return input_fn
RawResult = collections.namedtuple("RawResult",
["unique_id", "start_logits", "end_logits"])
def write_predictions(all_examples, all_features, all_results, n_best_size,
max_answer_length, do_lower_case, output_prediction_file,
output_nbest_file, output_null_log_odds_file):
"""Write final predictions to the json file and log-odds of null if needed."""
tf.logging.info("Writing predictions to: %s" % (output_prediction_file))
tf.logging.info("Writing nbest to: %s" % (output_nbest_file))
example_index_to_features = collections.defaultdict(list)
for feature in all_features:
example_index_to_features[feature.example_index].append(feature)
unique_id_to_result = {}
for result in all_results:
unique_id_to_result[result.unique_id] = result
_PrelimPrediction = collections.namedtuple( # pylint: disable=invalid-name
"PrelimPrediction",
["feature_index", "start_index", "end_index", "start_logit", "end_logit"])
all_predictions = collections.OrderedDict()
all_nbest_json = collections.OrderedDict()
scores_diff_json = collections.OrderedDict()
for (example_index, example) in enumerate(all_examples):
features = example_index_to_features[example_index]
prelim_predictions = []
# keep track of the minimum score of null start+end of position 0
score_null = 1000000 # large and positive
min_null_feature_index = 0 # the paragraph slice with min mull score
null_start_logit = 0 # the start logit at the slice with min null score
null_end_logit = 0 # the end logit at the slice with min null score
for (feature_index, feature) in enumerate(features):
result = unique_id_to_result[feature.unique_id]
start_indexes = _get_best_indexes(result.start_logits, n_best_size)
end_indexes = _get_best_indexes(result.end_logits, n_best_size)
# if we could have irrelevant answers, get the min score of irrelevant
if FLAGS.version_2_with_negative:
feature_null_score = result.start_logits[0] + result.end_logits[0]
if feature_null_score < score_null:
score_null = feature_null_score
min_null_feature_index = feature_index
null_start_logit = result.start_logits[0]
null_end_logit = result.end_logits[0]
for start_index in start_indexes:
for end_index in end_indexes:
# We could hypothetically create invalid predictions, e.g., predict
# that the start of the span is in the question. We throw out all
# invalid predictions.
if start_index >= len(feature.tokens):
continue
if end_index >= len(feature.tokens):
continue
if start_index not in feature.token_to_orig_map:
continue
if end_index not in feature.token_to_orig_map:
continue
if not feature.token_is_max_context.get(start_index, False):
continue
if end_index < start_index:
continue
length = end_index - start_index + 1
if length > max_answer_length:
continue
prelim_predictions.append(
_PrelimPrediction(
feature_index=feature_index,
start_index=start_index,
end_index=end_index,
start_logit=result.start_logits[start_index],
end_logit=result.end_logits[end_index]))
if FLAGS.version_2_with_negative:
prelim_predictions.append(
_PrelimPrediction(
feature_index=min_null_feature_index,
start_index=0,
end_index=0,
start_logit=null_start_logit,
end_logit=null_end_logit))
prelim_predictions = sorted(
prelim_predictions,
key=lambda x: (x.start_logit + x.end_logit),
reverse=True)
_NbestPrediction = collections.namedtuple( # pylint: disable=invalid-name
"NbestPrediction", ["text", "start_logit", "end_logit"])
seen_predictions = {}
nbest = []
for pred in prelim_predictions:
if len(nbest) >= n_best_size:
break
feature = features[pred.feature_index]
if pred.start_index > 0: # this is a non-null prediction
tok_tokens = feature.tokens[pred.start_index:(pred.end_index + 1)]
orig_doc_start = feature.token_to_orig_map[pred.start_index]
orig_doc_end = feature.token_to_orig_map[pred.end_index]
orig_tokens = example.doc_tokens[orig_doc_start:(orig_doc_end + 1)]
tok_text = " ".join(tok_tokens)
# De-tokenize WordPieces that have been split off.
tok_text = tok_text.replace(" ##", "")
tok_text = tok_text.replace("##", "")
# Clean whitespace
tok_text = tok_text.strip()
tok_text = " ".join(tok_text.split())
orig_text = " ".join(orig_tokens)
final_text = get_final_text(tok_text, orig_text, do_lower_case)
if final_text in seen_predictions:
continue
seen_predictions[final_text] = True
else:
final_text = ""
seen_predictions[final_text] = True
nbest.append(
_NbestPrediction(
text=final_text,
start_logit=pred.start_logit,
end_logit=pred.end_logit))
# if we didn't inlude the empty option in the n-best, inlcude it
if FLAGS.version_2_with_negative:
if "" not in seen_predictions:
nbest.append(
_NbestPrediction(
text="", start_logit=null_start_logit,
end_logit=null_end_logit))
# In very rare edge cases we could have no valid predictions. So we
# just create a nonce prediction in this case to avoid failure.
if not nbest:
nbest.append(
_NbestPrediction(text="empty", start_logit=0.0, end_logit=0.0))
assert len(nbest) >= 1
total_scores = []
best_non_null_entry = None
for entry in nbest:
total_scores.append(entry.start_logit + entry.end_logit)
if not best_non_null_entry:
if entry.text:
best_non_null_entry = entry
probs = _compute_softmax(total_scores)
nbest_json = []
for (i, entry) in enumerate(nbest):
output = collections.OrderedDict()
output["text"] = entry.text
output["probability"] = probs[i]
output["start_logit"] = entry.start_logit
output["end_logit"] = entry.end_logit
nbest_json.append(output)
assert len(nbest_json) >= 1
if not FLAGS.version_2_with_negative:
all_predictions[example.qas_id] = nbest_json[0]["text"]
else:
# predict "" iff the null score - the score of best non-null > threshold
score_diff = score_null - best_non_null_entry.start_logit - (
best_non_null_entry.end_logit)
scores_diff_json[example.qas_id] = score_diff
if score_diff > FLAGS.null_score_diff_threshold:
all_predictions[example.qas_id] = ""
else:
all_predictions[example.qas_id] = best_non_null_entry.text
all_nbest_json[example.qas_id] = nbest_json
with tf.gfile.GFile(output_prediction_file, "w") as writer:
writer.write(json.dumps(all_predictions, indent=4) + "\n")
with tf.gfile.GFile(output_nbest_file, "w") as writer:
writer.write(json.dumps(all_nbest_json, indent=4) + "\n")
if FLAGS.version_2_with_negative:
with tf.gfile.GFile(output_null_log_odds_file, "w") as writer:
writer.write(json.dumps(scores_diff_json, indent=4) + "\n")
def get_final_text(pred_text, orig_text, do_lower_case):
"""Project the tokenized prediction back to the original text."""
# When we created the data, we kept track of the alignment between original
# (whitespace tokenized) tokens and our WordPiece tokenized tokens. So
# now `orig_text` contains the span of our original text corresponding to the
# span that we predicted.
#
# However, `orig_text` may contain extra characters that we don't want in
# our prediction.
#
# For example, let's say:
# pred_text = steve smith
# orig_text = Steve Smith's
#
# We don't want to return `orig_text` because it contains the extra "'s".
#
# We don't want to return `pred_text` because it's already been normalized
# (the SQuAD eval script also does punctuation stripping/lower casing but
# our tokenizer does additional normalization like stripping accent
# characters).
#
# What we really want to return is "Steve Smith".
#
# Therefore, we have to apply a semi-complicated alignment heruistic between
# `pred_text` and `orig_text` to get a character-to-charcter alignment. This
# can fail in certain cases in which case we just return `orig_text`.
def _strip_spaces(text):
ns_chars = []
ns_to_s_map = collections.OrderedDict()
for (i, c) in enumerate(text):
if c == " ":
continue
ns_to_s_map[len(ns_chars)] = i
ns_chars.append(c)
ns_text = "".join(ns_chars)
return (ns_text, ns_to_s_map)
# We first tokenize `orig_text`, strip whitespace from the result
# and `pred_text`, and check if they are the same length. If they are
# NOT the same length, the heuristic has failed. If they are the same
# length, we assume the characters are one-to-one aligned.
tokenizer = tokenization.BasicTokenizer(do_lower_case=do_lower_case)
tok_text = " ".join(tokenizer.tokenize(orig_text))
start_position = tok_text.find(pred_text)
if start_position == -1:
if FLAGS.verbose_logging:
tf.logging.info(
"Unable to find text: '%s' in '%s'" % (pred_text, orig_text))
return orig_text
end_position = start_position + len(pred_text) - 1
(orig_ns_text, orig_ns_to_s_map) = _strip_spaces(orig_text)
(tok_ns_text, tok_ns_to_s_map) = _strip_spaces(tok_text)
if len(orig_ns_text) != len(tok_ns_text):
if FLAGS.verbose_logging:
tf.logging.info("Length not equal after stripping spaces: '%s' vs '%s'",
orig_ns_text, tok_ns_text)
return orig_text
# We then project the characters in `pred_text` back to `orig_text` using
# the character-to-character alignment.
tok_s_to_ns_map = {}
for (i, tok_index) in six.iteritems(tok_ns_to_s_map):
tok_s_to_ns_map[tok_index] = i
orig_start_position = None
if start_position in tok_s_to_ns_map:
ns_start_position = tok_s_to_ns_map[start_position]
if ns_start_position in orig_ns_to_s_map:
orig_start_position = orig_ns_to_s_map[ns_start_position]
if orig_start_position is None:
if FLAGS.verbose_logging:
tf.logging.info("Couldn't map start position")
return orig_text
orig_end_position = None
if end_position in tok_s_to_ns_map:
ns_end_position = tok_s_to_ns_map[end_position]
if ns_end_position in orig_ns_to_s_map:
orig_end_position = orig_ns_to_s_map[ns_end_position]
if orig_end_position is None:
if FLAGS.verbose_logging:
tf.logging.info("Couldn't map end position")
return orig_text
output_text = orig_text[orig_start_position:(orig_end_position + 1)]
return output_text
def _get_best_indexes(logits, n_best_size):
"""Get the n-best logits from a list."""
index_and_score = sorted(enumerate(logits), key=lambda x: x[1], reverse=True)
best_indexes = []
for i in range(len(index_and_score)):
if i >= n_best_size:
break
best_indexes.append(index_and_score[i][0])
return best_indexes
def _compute_softmax(scores):
"""Compute softmax probability over raw logits."""
if not scores:
return []
max_score = None
for score in scores:
if max_score is None or score > max_score:
max_score = score
exp_scores = []
total_sum = 0.0
for score in scores:
x = math.exp(score - max_score)
exp_scores.append(x)
total_sum += x
probs = []
for score in exp_scores:
probs.append(score / total_sum)
return probs
class FeatureWriter(object):
"""Writes InputFeature to TF example file."""
def __init__(self, filename, is_training):
self.filename = filename
self.is_training = is_training
self.num_features = 0
self._writer = tf.python_io.TFRecordWriter(filename)
def process_feature(self, feature):
"""Write a InputFeature to the TFRecordWriter as a tf.train.Example."""
self.num_features += 1
def create_int_feature(values):
feature = tf.train.Feature(
int64_list=tf.train.Int64List(value=list(values)))
return feature
features = collections.OrderedDict()
features["unique_ids"] = create_int_feature([feature.unique_id])
features["input_ids"] = create_int_feature(feature.input_ids)
features["input_mask"] = create_int_feature(feature.input_mask)
features["segment_ids"] = create_int_feature(feature.segment_ids)
if self.is_training:
features["start_positions"] = create_int_feature([feature.start_position])
features["end_positions"] = create_int_feature([feature.end_position])
impossible = 0
if feature.is_impossible:
impossible = 1
features["is_impossible"] = create_int_feature([impossible])
tf_example = tf.train.Example(features=tf.train.Features(feature=features))
self._writer.write(tf_example.SerializeToString())
def close(self):
self._writer.close()
def validate_flags_or_throw(bert_config):
"""Validate the input FLAGS or throw an exception."""
tokenization.validate_case_matches_checkpoint(FLAGS.do_lower_case,
FLAGS.init_checkpoint)
if not FLAGS.do_train and not FLAGS.do_predict:
raise ValueError("At least one of `do_train` or `do_predict` must be True.")
if FLAGS.do_train:
if not FLAGS.train_file:
raise ValueError(
"If `do_train` is True, then `train_file` must be specified.")
if FLAGS.do_predict:
if not FLAGS.predict_file:
raise ValueError(
"If `do_predict` is True, then `predict_file` must be specified.")
if FLAGS.max_seq_length > bert_config.max_position_embeddings:
raise ValueError(
"Cannot use sequence length %d because the BERT model "
"was only trained up to sequence length %d" %
(FLAGS.max_seq_length, bert_config.max_position_embeddings))
if FLAGS.max_seq_length <= FLAGS.max_query_length + 3:
raise ValueError(
"The max_seq_length (%d) must be greater than max_query_length "
"(%d) + 3" % (FLAGS.max_seq_length, FLAGS.max_query_length))
def main(_):
tf.logging.set_verbosity(tf.logging.INFO)
bert_config = modeling.BertConfig.from_json_file(FLAGS.bert_config_file)
validate_flags_or_throw(bert_config)
tf.gfile.MakeDirs(FLAGS.output_dir)
tokenizer = tokenization.FullTokenizer(
vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)
tpu_cluster_resolver = None
if FLAGS.use_tpu and FLAGS.tpu_name:
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
FLAGS.tpu_name, zone=FLAGS.tpu_zone, project=FLAGS.gcp_project)
is_per_host = tf.contrib.tpu.InputPipelineConfig.PER_HOST_V2
run_config = tf.contrib.tpu.RunConfig(
cluster=tpu_cluster_resolver,
master=FLAGS.master,
model_dir=FLAGS.output_dir,
save_checkpoints_steps=FLAGS.save_checkpoints_steps,
tpu_config=tf.contrib.tpu.TPUConfig(
iterations_per_loop=FLAGS.iterations_per_loop,
num_shards=FLAGS.num_tpu_cores,
per_host_input_for_training=is_per_host))
train_examples = None
num_train_steps = None
num_warmup_steps = None
if FLAGS.do_train:
train_examples = read_squad_examples(
input_file=FLAGS.train_file, is_training=True)
num_train_steps = int(
len(train_examples) / FLAGS.train_batch_size * FLAGS.num_train_epochs)
num_warmup_steps = int(num_train_steps * FLAGS.warmup_proportion)
# Pre-shuffle the input to avoid having to make a very large shuffle
# buffer in in the `input_fn`.
rng = random.Random(12345)
rng.shuffle(train_examples)
model_fn = model_fn_builder(
bert_config=bert_config,
init_checkpoint=FLAGS.init_checkpoint,
learning_rate=FLAGS.learning_rate,
num_train_steps=num_train_steps,
num_warmup_steps=num_warmup_steps,
use_tpu=FLAGS.use_tpu,
use_one_hot_embeddings=FLAGS.use_tpu)
# If TPU is not available, this will fall back to normal Estimator on CPU
# or GPU.
estimator = tf.contrib.tpu.TPUEstimator(
use_tpu=FLAGS.use_tpu,
model_fn=model_fn,
config=run_config,
train_batch_size=FLAGS.train_batch_size,
predict_batch_size=FLAGS.predict_batch_size)
if FLAGS.do_train:
# We write to a temporary file to avoid storing very large constant tensors
# in memory.
train_writer = FeatureWriter(
filename=os.path.join(FLAGS.output_dir, "train.tf_record"),
is_training=True)
convert_examples_to_features(
examples=train_examples,
tokenizer=tokenizer,
max_seq_length=FLAGS.max_seq_length,
doc_stride=FLAGS.doc_stride,
max_query_length=FLAGS.max_query_length,
is_training=True,
output_fn=train_writer.process_feature)
train_writer.close()
tf.logging.info("***** Running training *****")
tf.logging.info(" Num orig examples = %d", len(train_examples))
tf.logging.info(" Num split examples = %d", train_writer.num_features)
tf.logging.info(" Batch size = %d", FLAGS.train_batch_size)
tf.logging.info(" Num steps = %d", num_train_steps)
del train_examples
train_input_fn = input_fn_builder(
input_file=train_writer.filename,
seq_length=FLAGS.max_seq_length,
is_training=True,
drop_remainder=True)
estimator.train(input_fn=train_input_fn, max_steps=num_train_steps)
if FLAGS.do_predict:
eval_examples = read_squad_examples(
input_file=FLAGS.predict_file, is_training=False)
eval_writer = FeatureWriter(
filename=os.path.join(FLAGS.output_dir, "eval.tf_record"),
is_training=False)
eval_features = []
def append_feature(feature):
eval_features.append(feature)
eval_writer.process_feature(feature)
convert_examples_to_features(
examples=eval_examples,
tokenizer=tokenizer,
max_seq_length=FLAGS.max_seq_length,
doc_stride=FLAGS.doc_stride,
max_query_length=FLAGS.max_query_length,
is_training=False,
output_fn=append_feature)
eval_writer.close()
tf.logging.info("***** Running predictions *****")
tf.logging.info(" Num orig examples = %d", len(eval_examples))
tf.logging.info(" Num split examples = %d", len(eval_features))
tf.logging.info(" Batch size = %d", FLAGS.predict_batch_size)
all_results = []
predict_input_fn = input_fn_builder(
input_file=eval_writer.filename,
seq_length=FLAGS.max_seq_length,
is_training=False,
drop_remainder=False)
# If running eval on the TPU, you will need to specify the number of
# steps.
all_results = []
for result in estimator.predict(
predict_input_fn, yield_single_examples=True):
if len(all_results) % 1000 == 0:
tf.logging.info("Processing example: %d" % (len(all_results)))
unique_id = int(result["unique_ids"])
start_logits = [float(x) for x in result["start_logits"].flat]
end_logits = [float(x) for x in result["end_logits"].flat]
all_results.append(
RawResult(
unique_id=unique_id,
start_logits=start_logits,
end_logits=end_logits))
output_prediction_file = os.path.join(FLAGS.output_dir, "predictions.json")
output_nbest_file = os.path.join(FLAGS.output_dir, "nbest_predictions.json")
output_null_log_odds_file = os.path.join(FLAGS.output_dir, "null_odds.json")
write_predictions(eval_examples, eval_features, all_results,
FLAGS.n_best_size, FLAGS.max_answer_length,
FLAGS.do_lower_case, output_prediction_file,
output_nbest_file, output_null_log_odds_file)
if __name__ == "__main__":
flags.mark_flag_as_required("vocab_file")
flags.mark_flag_as_required("bert_config_file")
flags.mark_flag_as_required("output_dir")
tf.app.run()
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tokenization classes."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import re
import unicodedata
import six
import tensorflow as tf
def validate_case_matches_checkpoint(do_lower_case, init_checkpoint):
"""Checks whether the casing config is consistent with the checkpoint name."""
# The casing has to be passed in by the user and there is no explicit check
# as to whether it matches the checkpoint. The casing information probably
# should have been stored in the bert_config.json file, but it's not, so
# we have to heuristically detect it to validate.
if not init_checkpoint:
return
m = re.match("^.*?([A-Za-z0-9_-]+)/bert_model.ckpt", init_checkpoint)
if m is None:
return
model_name = m.group(1)
lower_models = [
"uncased_L-24_H-1024_A-16", "uncased_L-12_H-768_A-12",
"multilingual_L-12_H-768_A-12", "chinese_L-12_H-768_A-12"
]
cased_models = [
"cased_L-12_H-768_A-12", "cased_L-24_H-1024_A-16",
"multi_cased_L-12_H-768_A-12"
]
is_bad_config = False
if model_name in lower_models and not do_lower_case:
is_bad_config = True
actual_flag = "False"
case_name = "lowercased"
opposite_flag = "True"
if model_name in cased_models and do_lower_case:
is_bad_config = True
actual_flag = "True"
case_name = "cased"
opposite_flag = "False"
if is_bad_config:
raise ValueError(
"You passed in `--do_lower_case=%s` with `--init_checkpoint=%s`. "
"However, `%s` seems to be a %s model, so you "
"should pass in `--do_lower_case=%s` so that the fine-tuning matches "
"how the model was pre-training. If this error is wrong, please "
"just comment out this check." % (actual_flag, init_checkpoint,
model_name, case_name, opposite_flag))
def convert_to_unicode(text):
"""Converts `text` to Unicode (if it's not already), assuming utf-8 input."""
if six.PY3:
if isinstance(text, str):
return text
elif isinstance(text, bytes):
return text.decode("utf-8", "ignore")
else:
raise ValueError("Unsupported string type: %s" % (type(text)))
elif six.PY2:
if isinstance(text, str):
return text.decode("utf-8", "ignore")
elif isinstance(text, unicode):
return text
else:
raise ValueError("Unsupported string type: %s" % (type(text)))
else:
raise ValueError("Not running on Python2 or Python 3?")
def printable_text(text):
"""Returns text encoded in a way suitable for print or `tf.logging`."""
# These functions want `str` for both Python2 and Python3, but in one case
# it's a Unicode string and in the other it's a byte string.
if six.PY3:
if isinstance(text, str):
return text
elif isinstance(text, bytes):
return text.decode("utf-8", "ignore")
else:
raise ValueError("Unsupported string type: %s" % (type(text)))
elif six.PY2:
if isinstance(text, str):
return text
elif isinstance(text, unicode):
return text.encode("utf-8")
else:
raise ValueError("Unsupported string type: %s" % (type(text)))
else:
raise ValueError("Not running on Python2 or Python 3?")
def load_vocab(vocab_file):
"""Loads a vocabulary file into a dictionary."""
vocab = collections.OrderedDict()
index = 0
with tf.gfile.GFile(vocab_file, "r") as reader:
while True:
token = convert_to_unicode(reader.readline())
if not token:
break
token = token.strip()
vocab[token] = index
index += 1
return vocab
def convert_by_vocab(vocab, items):
"""Converts a sequence of [tokens|ids] using the vocab."""
output = []
for item in items:
output.append(vocab[item])
return output
def convert_tokens_to_ids(vocab, tokens):
return convert_by_vocab(vocab, tokens)
def convert_ids_to_tokens(inv_vocab, ids):
return convert_by_vocab(inv_vocab, ids)
def whitespace_tokenize(text):
"""Runs basic whitespace cleaning and splitting on a piece of text."""
text = text.strip()
if not text:
return []
tokens = text.split()
return tokens
class FullTokenizer(object):
"""Runs end-to-end tokenziation."""
def __init__(self, vocab_file, do_lower_case=True):
self.vocab = load_vocab(vocab_file)
self.inv_vocab = {v: k for k, v in self.vocab.items()}
self.basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)
self.wordpiece_tokenizer = WordpieceTokenizer(vocab=self.vocab)
def tokenize(self, text):
split_tokens = []
for token in self.basic_tokenizer.tokenize(text):
for sub_token in self.wordpiece_tokenizer.tokenize(token):
split_tokens.append(sub_token)
return split_tokens
def convert_tokens_to_ids(self, tokens):
return convert_by_vocab(self.vocab, tokens)
def convert_ids_to_tokens(self, ids):
return convert_by_vocab(self.inv_vocab, ids)
class BasicTokenizer(object):
"""Runs basic tokenization (punctuation splitting, lower casing, etc.)."""
def __init__(self, do_lower_case=True):
"""Constructs a BasicTokenizer.
Args:
do_lower_case: Whether to lower case the input.
"""
self.do_lower_case = do_lower_case
def tokenize(self, text):
"""Tokenizes a piece of text."""
text = convert_to_unicode(text)
text = self._clean_text(text)
# This was added on November 1st, 2018 for the multilingual and Chinese
# models. This is also applied to the English models now, but it doesn't
# matter since the English models were not trained on any Chinese data
# and generally don't have any Chinese data in them (there are Chinese
# characters in the vocabulary because Wikipedia does have some Chinese
# words in the English Wikipedia.).
text = self._tokenize_chinese_chars(text)
orig_tokens = whitespace_tokenize(text)
split_tokens = []
for token in orig_tokens:
if self.do_lower_case:
token = token.lower()
token = self._run_strip_accents(token)
split_tokens.extend(self._run_split_on_punc(token))
output_tokens = whitespace_tokenize(" ".join(split_tokens))
return output_tokens
def _run_strip_accents(self, text):
"""Strips accents from a piece of text."""
text = unicodedata.normalize("NFD", text)
output = []
for char in text:
cat = unicodedata.category(char)
if cat == "Mn":
continue
output.append(char)
return "".join(output)
def _run_split_on_punc(self, text):
"""Splits punctuation on a piece of text."""
chars = list(text)
i = 0
start_new_word = True
output = []
while i < len(chars):
char = chars[i]
if _is_punctuation(char):
output.append([char])
start_new_word = True
else:
if start_new_word:
output.append([])
start_new_word = False
output[-1].append(char)
i += 1
return ["".join(x) for x in output]
def _tokenize_chinese_chars(self, text):
"""Adds whitespace around any CJK character."""
output = []
for char in text:
cp = ord(char)
if self._is_chinese_char(cp):
output.append(" ")
output.append(char)
output.append(" ")
else:
output.append(char)
return "".join(output)
def _is_chinese_char(self, cp):
"""Checks whether CP is the codepoint of a CJK character."""
# This defines a "chinese character" as anything in the CJK Unicode block:
# https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
#
# Note that the CJK Unicode block is NOT all Japanese and Korean characters,
# despite its name. The modern Korean Hangul alphabet is a different block,
# as is Japanese Hiragana and Katakana. Those alphabets are used to write
# space-separated words, so they are not treated specially and handled
# like the all of the other languages.
if ((cp >= 0x4E00 and cp <= 0x9FFF) or #
(cp >= 0x3400 and cp <= 0x4DBF) or #
(cp >= 0x20000 and cp <= 0x2A6DF) or #
(cp >= 0x2A700 and cp <= 0x2B73F) or #
(cp >= 0x2B740 and cp <= 0x2B81F) or #
(cp >= 0x2B820 and cp <= 0x2CEAF) or
(cp >= 0xF900 and cp <= 0xFAFF) or #
(cp >= 0x2F800 and cp <= 0x2FA1F)): #
return True
return False
def _clean_text(self, text):
"""Performs invalid character removal and whitespace cleanup on text."""
output = []
for char in text:
cp = ord(char)
if cp == 0 or cp == 0xfffd or _is_control(char):
continue
if _is_whitespace(char):
output.append(" ")
else:
output.append(char)
return "".join(output)
class WordpieceTokenizer(object):
"""Runs WordPiece tokenziation."""
def __init__(self, vocab, unk_token="[UNK]", max_input_chars_per_word=200):
self.vocab = vocab
self.unk_token = unk_token
self.max_input_chars_per_word = max_input_chars_per_word
def tokenize(self, text):
"""Tokenizes a piece of text into its word pieces.
This uses a greedy longest-match-first algorithm to perform tokenization
using the given vocabulary.
For example:
input = "unaffable"
output = ["un", "##aff", "##able"]
Args:
text: A single token or whitespace separated tokens. This should have
already been passed through `BasicTokenizer.
Returns:
A list of wordpiece tokens.
"""
text = convert_to_unicode(text)
output_tokens = []
for token in whitespace_tokenize(text):
chars = list(token)
if len(chars) > self.max_input_chars_per_word:
output_tokens.append(self.unk_token)
continue
is_bad = False
start = 0
sub_tokens = []
while start < len(chars):
end = len(chars)
cur_substr = None
while start < end:
substr = "".join(chars[start:end])
if start > 0:
substr = "##" + substr
if substr in self.vocab:
cur_substr = substr
break
end -= 1
if cur_substr is None:
is_bad = True
break
sub_tokens.append(cur_substr)
start = end
if is_bad:
output_tokens.append(self.unk_token)
else:
output_tokens.extend(sub_tokens)
return output_tokens
def _is_whitespace(char):
"""Checks whether `chars` is a whitespace character."""
# \t, \n, and \r are technically contorl characters but we treat them
# as whitespace since they are generally considered as such.
if char == " " or char == "\t" or char == "\n" or char == "\r":
return True
cat = unicodedata.category(char)
if cat == "Zs":
return True
return False
def _is_control(char):
"""Checks whether `chars` is a control character."""
# These are technically control characters but we count them as whitespace
# characters.
if char == "\t" or char == "\n" or char == "\r":
return False
cat = unicodedata.category(char)
if cat in ("Cc", "Cf"):
return True
return False
def _is_punctuation(char):
"""Checks whether `chars` is a punctuation character."""
cp = ord(char)
# We treat all non-letter/number ASCII as punctuation.
# Characters such as "^", "$", and "`" are not in the Unicode
# Punctuation class but we treat them as punctuation anyways, for
# consistency.
if ((cp >= 33 and cp <= 47) or (cp >= 58 and cp <= 64) or
(cp >= 91 and cp <= 96) or (cp >= 123 and cp <= 126)):
return True
cat = unicodedata.category(char)
if cat.startswith("P"):
return True
return False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.