def test_model(coco_instances, backbone, head): datamodule = InstanceSegmentationData.from_coco( train_folder=coco_instances.train_folder, train_ann_file=coco_instances.train_ann_file, predict_folder=coco_instances.predict_folder, transform_kwargs=dict(image_size=(128, 128)), batch_size=2, ) assert datamodule.num_classes == 3 assert datamodule.labels == ["background", "cat", "dog"] model = InstanceSegmentation(num_classes=datamodule.num_classes, backbone=backbone, head=head) trainer = Trainer(fast_dev_run=True) trainer.fit(model, datamodule=datamodule) trainer.predict(model, datamodule=datamodule)
def test_predict_sklearn(): """Tests that we can generate predictions from a scikit-learn ``Bunch``.""" bunch = datasets.load_iris() model = TemplateSKLearnClassifier(num_features=DummyDataset.num_features, num_classes=DummyDataset.num_classes) datamodule = TemplateData.from_sklearn(predict_bunch=bunch, batch_size=1) trainer = Trainer() out = trainer.predict(model, datamodule=datamodule, output="classes") assert isinstance(out[0][0], int)
def test_predict_numpy(): """Tests that we can generate predictions from a numpy array.""" row = np.random.rand(1, DummyDataset.num_features) model = TemplateSKLearnClassifier(num_features=DummyDataset.num_features, num_classes=DummyDataset.num_classes) datamodule = TemplateData.from_numpy(predict_data=row, batch_size=1) trainer = Trainer() out = trainer.predict(model, datamodule=datamodule, output="classes") assert isinstance(out[0][0], int)
def test_predict_numpy(): img = np.ones((1, 3, 64, 64)) model = SemanticSegmentation(2, backbone="mobilenetv3_large_100") datamodule = SemanticSegmentationData.from_numpy(predict_data=img, batch_size=1) trainer = Trainer() out = trainer.predict(model, datamodule=datamodule, output="labels") assert isinstance(out[0][0], list) assert len(out[0][0]) == 64 assert len(out[0][0][0]) == 64
def test_predict_dataset(tmpdir): """Tests that we can generate embeddings from a pytorch geometric dataset.""" tudataset = datasets.TUDataset(root=tmpdir, name="KKI") model = GraphEmbedder( GraphClassifier(num_features=tudataset.num_features, num_classes=tudataset.num_classes).backbone) datamodule = DataModule( predict_input=GraphClassificationDatasetInput(RunningStage.PREDICTING, tudataset), transform=GraphClassificationInputTransform, batch_size=4, ) trainer = Trainer(default_root_dir=tmpdir, fast_dev_run=True) out = trainer.predict(model, datamodule=datamodule) assert isinstance(out[0][0], torch.Tensor)
def test_pointcloud_segmentation_data(tmpdir): seed_everything(52) download_data( "https://pl-flash-data.s3.amazonaws.com/SemanticKittiMicro.zip", tmpdir) datamodule = PointCloudSegmentationData.from_folders( train_folder=join(tmpdir, "SemanticKittiMicro", "train"), predict_folder=join(tmpdir, "SemanticKittiMicro", "predict"), batch_size=4, ) class MockModel(PointCloudSegmentation): def training_step(self, batch, batch_idx: int): assert batch[DataKeys.INPUT]["xyz"][0].shape == torch.Size( [2, 45056, 3]) assert batch[DataKeys.INPUT]["xyz"][1].shape == torch.Size( [2, 11264, 3]) assert batch[DataKeys.INPUT]["xyz"][2].shape == torch.Size( [2, 2816, 3]) assert batch[DataKeys.INPUT]["xyz"][3].shape == torch.Size( [2, 704, 3]) assert batch[DataKeys.INPUT]["labels"].shape == torch.Size( [2, 45056]) assert batch[DataKeys.INPUT]["labels"].max() == 19 assert batch[DataKeys.INPUT]["labels"].min() == 0 assert batch[DataKeys.METADATA][0]["name"] in ("00_000000", "00_000001") assert batch[DataKeys.METADATA][1]["name"] in ("00_000000", "00_000001") num_classes = 19 model = MockModel(backbone="randlanet", num_classes=num_classes) trainer = Trainer(max_epochs=1, limit_train_batches=1, limit_val_batches=0) trainer.fit(model, datamodule=datamodule) predictions = trainer.predict(model, datamodule=datamodule)[0] assert predictions[0][DataKeys.INPUT].shape == torch.Size([45056, 3]) assert predictions[0][DataKeys.PREDS].shape == torch.Size([45056, 19]) assert predictions[0][DataKeys.TARGET].shape == torch.Size([45056])
def test_data_module(): seed_everything(42) def train_fn(data): return data - 100 def val_fn(data): return data + 100 def test_fn(data): return data - 1000 def predict_fn(data): return data + 1000 @dataclass class TestTransform(InputTransform): def per_sample_transform(self): def fn(x): return x return fn def train_per_batch_transform_on_device(self) -> Callable: return train_fn def val_per_batch_transform_on_device(self) -> Callable: return val_fn def test_per_batch_transform_on_device(self) -> Callable: return test_fn def predict_per_batch_transform_on_device(self) -> Callable: return predict_fn transform = TestTransform() assert transform._transform is not None train_dataset = Input(RunningStage.TRAINING, np.arange(10, dtype=np.float32)) assert train_dataset.running_stage == RunningStage.TRAINING val_dataset = Input(RunningStage.VALIDATING, np.arange(10, dtype=np.float32)) assert val_dataset.running_stage == RunningStage.VALIDATING test_dataset = Input(RunningStage.TESTING, np.arange(10, dtype=np.float32)) assert test_dataset.running_stage == RunningStage.TESTING predict_dataset = Input(RunningStage.PREDICTING, np.arange(10, dtype=np.float32)) assert predict_dataset.running_stage == RunningStage.PREDICTING dm = DataModule( train_input=train_dataset, val_input=val_dataset, test_input=test_dataset, predict_input=predict_dataset, transform=transform, batch_size=2, ) assert len(dm.train_dataloader()) == 5 batch = next(iter(dm.train_dataloader())) assert batch.shape == torch.Size([2]) assert batch.min() >= 0 and batch.max() < 10 assert len(dm.val_dataloader()) == 5 batch = next(iter(dm.val_dataloader())) assert batch.shape == torch.Size([2]) assert batch.min() >= 0 and batch.max() < 10 class TestModel(Task): def training_step(self, batch, batch_idx): assert sum(batch < 0) == 2 def validation_step(self, batch, batch_idx): assert sum(batch > 0) == 2 def test_step(self, batch, batch_idx): assert sum(batch < 500) == 2 def predict_step(self, batch, *args, **kwargs): assert sum(batch > 500) == 2 assert torch.equal(batch, torch.tensor([1000.0, 1001.0])) def on_train_dataloader(self) -> None: pass def on_val_dataloader(self) -> None: pass def on_test_dataloader(self, *_) -> None: pass def on_predict_dataloader(self) -> None: pass def on_predict_end(self) -> None: pass def on_fit_end(self) -> None: pass model = TestModel(torch.nn.Linear(1, 1)) trainer = Trainer(fast_dev_run=True) trainer.fit(model, datamodule=dm) trainer.validate(model, datamodule=dm) trainer.test(model, datamodule=dm) trainer.predict(model, datamodule=dm) # Test that plain lightning module works with FlashDataModule class SampleBoringModel(BoringModel): def __init__(self): super().__init__() self.layer = torch.nn.Linear(2, 1) model = SampleBoringModel() trainer = Trainer(fast_dev_run=True) trainer.fit(model, datamodule=dm) trainer.validate(model, datamodule=dm) trainer.test(model, datamodule=dm) trainer.predict(model, datamodule=dm) transform = TestTransform() input = Input(RunningStage.TRAINING) dm = DataModule(train_input=input, batch_size=1, transform=transform) assert isinstance(dm.input_transform, TestTransform) class RandomDataset(Dataset): def __init__(self, size: int, length: int): self.len = length self.data = torch.ones(length, size) def __getitem__(self, index): return self.data[index] def __len__(self): return self.len def _add_hundred(x): if isinstance(x, Dict): x["input"] += 100 else: x += 100 return x class TrainInputTransform(InputTransform): def _add_one(self, x): if isinstance(x, Dict): x["input"] += 1 else: x += 1 return x def per_sample_transform(self) -> Callable: return self._add_one def val_per_sample_transform(self) -> Callable: return _add_hundred dm = DataModule( train_input=DatasetInput(RunningStage.TRAINING, RandomDataset(64, 32)), val_input=DatasetInput(RunningStage.VALIDATING, RandomDataset(64, 32)), test_input=DatasetInput(RunningStage.TESTING, RandomDataset(64, 32)), batch_size=3, transform=TrainInputTransform(), ) batch = next(iter(dm.train_dataloader())) assert batch["input"][0][0] == 2 batch = next(iter(dm.val_dataloader())) assert batch["input"][0][0] == 101 batch = next(iter(dm.test_dataloader())) assert batch["input"][0][0] == 2
""" The Normans (Norman: Nourmands; French: Normands; Latin: Normanni) were the people who in the 10th and 11th centuries gave their name to Normandy, a region in France. They were descended from Norse ("Norman" comes from "Norseman") raiders and pirates from Denmark, Iceland and Norway who, under their leader Rollo, agreed to swear fealty to King Charles III of West Francia. Through generations of assimilation and mixing with the native Frankish and Roman-Gaulish populations, their descendants would gradually merge with the Carolingian-based cultures of West Francia. The distinct cultural and ethnic identity of the Normans emerged initially in the first half of the 10th century, and it continued to evolve over the succeeding centuries. """, """ The Normans (Norman: Nourmands; French: Normands; Latin: Normanni) were the people who in the 10th and 11th centuries gave their name to Normandy, a region in France. They were descended from Norse ("Norman" comes from "Norseman") raiders and pirates from Denmark, Iceland and Norway who, under their leader Rollo, agreed to swear fealty to King Charles III of West Francia. Through generations of assimilation and mixing with the native Frankish and Roman-Gaulish populations, their descendants would gradually merge with the Carolingian-based cultures of West Francia. The distinct cultural and ethnic identity of the Normans emerged initially in the first half of the 10th century, and it continued to evolve over the succeeding centuries. """, ], "question": ["When were the Normans in Normandy?", "In what country is Normandy located?"], }, batch_size=4, ) predictions = trainer.predict(model, datamodule=datamodule) print(predictions) # 5. Save the model! trainer.save_checkpoint("question_answering_on_sqaud_v2.pt")