def test_from_filepaths_visualise(tmpdir):
tmpdir = Path(tmpdir)
(tmpdir / "e").mkdir()
_rand_image().save(tmpdir / "e_1.png")
train_images = [
str(tmpdir / "e_1.png"),
str(tmpdir / "e_1.png"),
str(tmpdir / "e_1.png"),
]
dm = ImageClassificationData.from_files(
train_files=train_images,
train_targets=[0, 3, 6],
val_files=train_images,
val_targets=[1, 4, 7],
test_files=train_images,
test_targets=[2, 5, 8],
batch_size=2,
num_workers=0,
)
# disable visualisation for testing
assert dm.data_fetcher.block_viz_window is True
dm.set_block_viz_window(False)
assert dm.data_fetcher.block_viz_window is False
# call show functions
# dm.show_train_batch()
dm.show_train_batch("pre_tensor_transform")
dm.show_train_batch(["pre_tensor_transform", "post_tensor_transform"])
def simple_datamodule(tmpdir):
train_dir = Path(tmpdir / "train")
train_dir.mkdir()
(train_dir / "a").mkdir()
pa_1 = train_dir / "a" / "1.png"
pa_2 = train_dir / "a" / "2.png"
pb_1 = train_dir / "b" / "1.png"
pb_2 = train_dir / "b" / "2.png"
image_size = (96, 96)
_rand_image(image_size).save(pa_1)
_rand_image(image_size).save(pa_2)
(train_dir / "b").mkdir()
_rand_image(image_size).save(pb_1)
_rand_image(image_size).save(pb_2)
n = 10
dm = ImageClassificationData.from_files(
train_files=[str(pa_1)] * n + [str(pa_2)] * n + [str(pb_1)] * n +
[str(pb_2)] * n,
train_targets=[0] * n + [1] * n + [2] * n + [3] * n,
test_files=[str(pa_1)] * n,
test_targets=[0] * n,
batch_size=2,
num_workers=0,
transform_kwargs=dict(image_size=image_size),
)
return dm
def test_from_filepaths_smoke(tmpdir):
tmpdir = Path(tmpdir)
(tmpdir / "a").mkdir()
(tmpdir / "b").mkdir()
_rand_image().save(tmpdir / "a_1.png")
_rand_image().save(tmpdir / "b_1.png")
train_images = [
str(tmpdir / "a_1.png"),
str(tmpdir / "b_1.png"),
]
img_data = ImageClassificationData.from_files(
train_files=train_images,
train_targets=[1, 2],
batch_size=2,
num_workers=0,
)
assert img_data.train_dataloader() is not None
assert img_data.val_dataloader() is None
assert img_data.test_dataloader() is None
data = next(iter(img_data.train_dataloader()))
imgs, labels = data['input'], data['target']
assert imgs.shape == (2, 3, 196, 196)
assert labels.shape == (2, )
assert sorted(list(labels.numpy())) == [1, 2]
def test_from_filepaths_visualise_multilabel(tmpdir):
tmpdir = Path(tmpdir)
(tmpdir / "a").mkdir()
(tmpdir / "b").mkdir()
image_a = str(tmpdir / "a" / "a_1.png")
image_b = str(tmpdir / "b" / "b_1.png")
_rand_image().save(image_a)
_rand_image().save(image_b)
dm = ImageClassificationData.from_files(
train_files=[image_a, image_b],
train_targets=[[0, 1, 0], [0, 1, 1]],
val_files=[image_b, image_a],
val_targets=[[1, 1, 0], [0, 0, 1]],
test_files=[image_b, image_b],
test_targets=[[0, 0, 1], [1, 1, 0]],
batch_size=2,
image_size=(64, 64),
)
# disable visualisation for testing
assert dm.data_fetcher.block_viz_window is True
dm.set_block_viz_window(False)
assert dm.data_fetcher.block_viz_window is False
# call show functions
dm.show_train_batch()
dm.show_train_batch("pre_tensor_transform")
dm.show_train_batch("to_tensor_transform")
dm.show_train_batch(["pre_tensor_transform", "post_tensor_transform"])
dm.show_val_batch("per_batch_transform")
def _test_learn2learning_training_strategies(gpus, accelerator, training_strategy, tmpdir):
train_dir = Path(tmpdir / "train")
train_dir.mkdir()
(train_dir / "a").mkdir()
pa_1 = train_dir / "a" / "1.png"
pa_2 = train_dir / "a" / "2.png"
pb_1 = train_dir / "b" / "1.png"
pb_2 = train_dir / "b" / "2.png"
image_size = (96, 96)
_rand_image(image_size).save(pa_1)
_rand_image(image_size).save(pa_2)
(train_dir / "b").mkdir()
_rand_image(image_size).save(pb_1)
_rand_image(image_size).save(pb_2)
n = 5
dm = ImageClassificationData.from_files(
train_files=[str(pa_1)] * n + [str(pa_2)] * n + [str(pb_1)] * n + [str(pb_2)] * n,
train_targets=[0] * n + [1] * n + [2] * n + [3] * n,
batch_size=1,
num_workers=0,
transform_kwargs=dict(image_size=image_size),
)
model = ImageClassifier(
backbone="resnet18",
training_strategy=training_strategy,
training_strategy_kwargs={"ways": dm.num_classes, "shots": 4, "meta_batch_size": 4},
)
trainer = Trainer(fast_dev_run=2, gpus=gpus, accelerator=accelerator)
trainer.fit(model, datamodule=dm)
def run(transform: Any = None):
dm = ImageClassificationData.from_files(
train_files=train_filepaths,
train_targets=train_labels,
transform=transform,
batch_size=B,
num_workers=0,
val_split=val_split,
)
data = next(iter(dm.train_dataloader()))
imgs, labels = data["input"], data["target"]
assert imgs.shape == (B, 3, H, W)
assert labels.shape == (B,)
def test_from_filepaths_list_image_paths(tmpdir):
tmpdir = Path(tmpdir)
(tmpdir / "e").mkdir()
_rand_image().save(tmpdir / "e_1.png")
train_images = [
str(tmpdir / "e_1.png"),
str(tmpdir / "e_1.png"),
str(tmpdir / "e_1.png"),
]
img_data = ImageClassificationData.from_files(
train_files=train_images,
train_targets=[0, 3, 6],
val_files=train_images,
val_targets=[1, 4, 7],
test_files=train_images,
test_targets=[2, 5, 8],
batch_size=2,
num_workers=0,
)
# check training data
data = next(iter(img_data.train_dataloader()))
imgs, labels = data['input'], data['target']
assert imgs.shape == (2, 3, 196, 196)
assert labels.shape == (2, )
assert labels.numpy()[0] in [0, 3, 6] # data comes shuffled here
assert labels.numpy()[1] in [0, 3, 6] # data comes shuffled here
# check validation data
data = next(iter(img_data.val_dataloader()))
imgs, labels = data['input'], data['target']
assert imgs.shape == (2, 3, 196, 196)
assert labels.shape == (2, )
assert list(labels.numpy()) == [1, 4]
# check test data
data = next(iter(img_data.test_dataloader()))
imgs, labels = data['input'], data['target']
assert imgs.shape == (2, 3, 196, 196)
assert labels.shape == (2, )
assert list(labels.numpy()) == [2, 5]
def test_from_filepaths_multilabel(tmpdir):
tmpdir = Path(tmpdir)
(tmpdir / "a").mkdir()
_rand_image().save(tmpdir / "a1.png")
_rand_image().save(tmpdir / "a2.png")
train_images = [str(tmpdir / "a1.png"), str(tmpdir / "a2.png")]
train_labels = [[1, 0, 1, 0], [0, 0, 1, 1]]
valid_labels = [[1, 1, 1, 0], [1, 0, 0, 1]]
test_labels = [[1, 0, 1, 0], [1, 1, 0, 1]]
dm = ImageClassificationData.from_files(
train_files=train_images,
train_targets=train_labels,
val_files=train_images,
val_targets=valid_labels,
test_files=train_images,
test_targets=test_labels,
batch_size=2,
num_workers=0,
)
data = next(iter(dm.train_dataloader()))
imgs, labels = data['input'], data['target']
assert imgs.shape == (2, 3, 196, 196)
assert labels.shape == (2, 4)
data = next(iter(dm.val_dataloader()))
imgs, labels = data['input'], data['target']
assert imgs.shape == (2, 3, 196, 196)
assert labels.shape == (2, 4)
torch.testing.assert_allclose(labels, torch.tensor(valid_labels))
data = next(iter(dm.test_dataloader()))
imgs, labels = data['input'], data['target']
assert imgs.shape == (2, 3, 196, 196)
assert labels.shape == (2, 4)
torch.testing.assert_allclose(labels, torch.tensor(test_labels))
def test_classification(tmpdir):
tmpdir = Path(tmpdir)
(tmpdir / "a").mkdir()
(tmpdir / "b").mkdir()
image_a = str(tmpdir / "a" / "a_1.png")
image_b = str(tmpdir / "b" / "b_1.png")
_rand_image().save(image_a)
_rand_image().save(image_b)
data = ImageClassificationData.from_files(
train_files=[image_a, image_b],
train_targets=[0, 1],
num_workers=0,
batch_size=2,
image_size=(64, 64),
)
model = ImageClassifier(num_classes=2, backbone="resnet18")
trainer = Trainer(default_root_dir=tmpdir, fast_dev_run=True)
trainer.finetune(model, datamodule=data, strategy="freeze")
root: str = 'data/movie_posters') -> Tuple[List[str], List[List[int]]]:
metadata = pd.read_csv(osp.join(root, data, "metadata.csv"))
return ([
osp.join(root, data, row['Id'] + ".jpg")
for _, row in metadata.iterrows()
], [[int(row[genre]) for genre in genres]
for _, row in metadata.iterrows()])
train_files, train_targets = load_data('train')
test_files, test_targets = load_data('test')
datamodule = ImageClassificationData.from_files(
train_files=train_files,
train_targets=train_targets,
test_files=test_files,
test_targets=test_targets,
val_split=0.1, # Use 10 % of the train dataset to generate validation one.
image_size=(128, 128),
)
# 3. Build the model
model = ImageClassifier(
backbone="resnet18",
num_classes=len(genres),
multi_label=True,
metrics=F1(num_classes=len(genres)),
)
# 4. Create the trainer. Train on 2 gpus for 10 epochs.
trainer = flash.Trainer(max_epochs=10)
val_split=0.2,
)
# 3. Fine tune a model
model = ImageClassifier(
backbone="resnet18",
num_classes=datamodule.num_classes,
)
trainer = flash.Trainer(max_epochs=3)
trainer.finetune(
model,
datamodule=datamodule,
strategy=("freeze_unfreeze", 1),
)
trainer.save_checkpoint("image_classification_model.pt")
# 4. Predict from checkpoint
model = ImageClassifier.load_from_checkpoint("image_classification_model.pt")
model.output = LabelsOutput()
datamodule = ImageClassificationData.from_files(predict_files=[
"data/test/1.jpg",
"data/test/2.jpg",
])
predictions = trainer.predict(model, datamodule=datamodule)
# 5. Visualize predictions
app = launch_app(datamodule)
print(app.show_predictions(predictions))
backbone="resnet18",
training_strategy="barlow_twins",
head="barlow_twins_head",
pretraining_transform="barlow_twins_transform",
training_strategy_kwargs={"latent_embedding_dim": 128},
pretraining_transform_kwargs={"size_crops": [32]},
)
# 3. Create the trainer and pre-train the encoder
trainer = flash.Trainer(max_epochs=1, gpus=torch.cuda.device_count())
trainer.fit(embedder, datamodule=datamodule)
# 4. Save the model!
trainer.save_checkpoint("image_embedder_model.pt")
# 5. Download the downstream prediction dataset and generate embeddings
download_data("https://pl-flash-data.s3.amazonaws.com/hymenoptera_data.zip",
"data/")
datamodule = ImageClassificationData.from_files(
predict_files=[
"data/hymenoptera_data/predict/153783656_85f9c3ac70.jpg",
"data/hymenoptera_data/predict/2039585088_c6f47c592e.jpg",
],
batch_size=3,
)
embeddings = trainer.predict(embedder, datamodule=datamodule)
# list of embeddings for images sent to the predict function
print(embeddings)
["Action", "Romance", "Crime", "Thriller", "Adventure"],
train_file="data/movie_posters/train/metadata.csv",
train_resolver=resolver,
val_file="data/movie_posters/val/metadata.csv",
val_resolver=resolver,
transform_kwargs={"image_size": (128, 128)},
batch_size=1,
)
# 2. Build the task
model = ImageClassifier(backbone="resnet18", labels=datamodule.labels, multi_label=datamodule.multi_label)
# 3. Create the trainer and finetune the model
trainer = flash.Trainer(max_epochs=3, gpus=torch.cuda.device_count())
trainer.finetune(model, datamodule=datamodule, strategy="freeze")
# 4. Predict the genre of a few movies!
datamodule = ImageClassificationData.from_files(
predict_files=[
"data/movie_posters/predict/tt0085318.jpg",
"data/movie_posters/predict/tt0089461.jpg",
"data/movie_posters/predict/tt0097179.jpg",
],
batch_size=3,
)
predictions = trainer.predict(model, datamodule=datamodule, output="labels")
print(predictions)
# 5. Save the model!
trainer.save_checkpoint("image_classification_multi_label_model.pt")
)
# 2. Build the task
head = torch.nn.Sequential(
torch.nn.Dropout(p=0.1),
torch.nn.Linear(512, datamodule.num_classes),
)
model = ImageClassifier(backbone="resnet18", head=head, num_classes=datamodule.num_classes)
# 3.1 Create the trainer
trainer = flash.Trainer(max_epochs=3)
# 3.2 Create the active learning loop and connect it to the trainer
active_learning_loop = ActiveLearningLoop(label_epoch_frequency=1)
active_learning_loop.connect(trainer.fit_loop)
trainer.fit_loop = active_learning_loop
# 3.3 Finetune
trainer.finetune(model, datamodule=datamodule, strategy="freeze")
# 4. Predict what's on a few images! ants or bees?
datamodule = ImageClassificationData.from_files(
predict_files=["data/hymenoptera_data/val/bees/65038344_52a45d090d.jpg"],
batch_size=1,
)
predictions = trainer.predict(model, datamodule=datamodule, output="probabilities")
print(predictions)
# 5. Save the model!
trainer.save_checkpoint("image_classification_model.pt")
val_folder="data/hymenoptera_data/val/",
batch_size=4,
transform_kwargs={
"image_size": (196, 196),
"mean": (0.485, 0.456, 0.406),
"std": (0.229, 0.224, 0.225)
},
)
# 2. Build the task
model = ImageClassifier(backbone="resnet18", labels=datamodule.labels)
# 3. Create the trainer and finetune the model
trainer = flash.Trainer(max_epochs=3, gpus=torch.cuda.device_count())
trainer.finetune(model, datamodule=datamodule, strategy="freeze")
# 4. Predict what's on a few images! ants or bees?
datamodule = ImageClassificationData.from_files(
predict_files=[
"data/hymenoptera_data/val/bees/65038344_52a45d090d.jpg",
"data/hymenoptera_data/val/bees/590318879_68cf112861.jpg",
"data/hymenoptera_data/val/ants/540543309_ddbb193ee5.jpg",
],
batch_size=3,
)
predictions = trainer.predict(model, datamodule=datamodule, output="labels")
print(predictions)
# 5. Save the model!
trainer.save_checkpoint("image_classification_model.pt")