class FailedModelArg(ModelComponent): def __init__(self, foo): pass @expose(inputs={"param": Number()}, outputs={"foo": Number()}) def predict(self, param): return param
class FailedExposedDecorator(ModelComponent): def __init__(self, model): self.model = model @expose(inputs={"NOT_NAMED": Number()}, outputs={"foo": Number()}) def predict(self, param): return param
class FailedInit(ModelComponent): def __init__(self, model, config, FOO): pass @expose(inputs={"param": Number()}, outputs={"foo": Number()}) def predict(self, param): return param
class SomeComponent(ModelComponent): def __init__(self, model): self.model = model @expose(inputs={"param": Number()}, outputs={"out": Number()}) def predict(self, param): return param
class FailedExposedOutputsKeyworkName(ModelComponent): def __init__(self, model): self.model = model @expose(inputs={"param": Number()}, outputs={"def": Number()}) def predict(self, param): return param
class ComposeClassInvalidExposeInputsType(ModelComponent): def __init__(self, model): pass @expose(inputs=Number(), outputs={"foo": Number()}) def predict(self, param): return param
class ComposeClassInvalidExposeNameType(ModelComponent): def __init__(self, model): pass @expose(inputs={"param": Number()}, outputs={12: Number()}) def predict(self, param): return param
class FailedConfig(ModelComponent): def __init__(self, model, OTHER): pass @expose(inputs={"param": Number()}, outputs={"foo": Number()}) @staticmethod def predict(param): return param
class ComposeClassInvalidExposeNameKeyword(ModelComponent): def __init__(self, model): pass @expose(inputs={"param": Number()}, outputs={"def": Number()}) @staticmethod def predict(param): return param
class ComponentTwoModels(ModelComponent): def __init__(self, model): self.encoder = model["encoder"] self.decoder = model["decoder"] @expose(inputs={"inp": Number()}, outputs={"output": Number()}) def do_my_predict(self, inp): """My predict docstring.""" return self.decoder(self.encoder(inp, inp), inp)
class FailedMethod_Inputs(ModelComponent): def __init__(self, model): pass @expose(inputs={"param": Number()}, outputs={"foo": Number()}) def predict(self, param): return param def inputs(self): pass
class FailedMethod_Name(ModelComponent): def __init__(self, model): pass @expose(inputs={"param": Number()}, outputs={"foo": Number()}) def predict(self, param): return param @property def uid(self): return f'{self.uid}_SHOULD_NOT_RETURN'
class FailedTwoExposed(ModelComponent): def __init__(self, model): pass @expose(inputs={"param": Number()}, outputs={"foo": Number()}) def predict(self, param): return param @expose(inputs={"param": Number()}, outputs={"foo": Number()}) def clasify(self, param): return param
class ComposeClassEmptyExposeInputsType(ModelComponent): def __init__(self, model): pass @expose(inputs={}, outputs={"foo": Number()}) @staticmethod def predict(param): return param
class PricePrediction(ModelComponent): def __init__(self, model): # skipcq: PYL-W0621 self.model = model @expose(inputs={"table": Table(column_names=feature_names)}, outputs={"pred": Number()}) def predict(self, table): return self.model(table)
class FailedExposedDecoratorClass(ModelComponent): def __init__(self, model): self.model = model @expose(inputs={"param": Number}, outputs={"foo": Number()}) @staticmethod def predict(param): return param
def test_serialize(): num = Number() tensor = torch.tensor([[1]]) assert 1 == num.serialize(tensor) assert isinstance(num.serialize(tensor.to(torch.float32)), float) assert isinstance(num.serialize(tensor.to(torch.float64)), float) assert isinstance(num.serialize(tensor.to(torch.int16)), int) assert isinstance(num.serialize(tensor.to(torch.int32)), int) assert isinstance(num.serialize(tensor.to(torch.int64)), int) assert isinstance(num.serialize(tensor.to(torch.complex64)), complex) tensor = torch.tensor([1, 2]) with pytest.raises(ValueError): # only one element tensors can be converted to Python scalars num.serialize(tensor)
class SeatClassifier(ModelComponent): def __init__(self, model, config): self.sport = config["sport"] @expose( inputs={ "section": Number(), "isle": Number(), "row": Number(), "stadium": Label(path=str(CWD / "imagenet_labels.txt")), }, outputs={ "seat_number": Number(), "team": Label(path=str(CWD / "imagenet_labels.txt")), }, ) def predict(self, section, isle, row, stadium): seat_num = section.item() * isle.item() * row.item( ) * stadium * len(self.sport) stadium_idx = torch.tensor(1000) return torch.Tensor([seat_num]), stadium_idx
class ClassificationInferenceRepeated(ModelComponent): def __init__(self, model): self.model = model @expose( inputs={"img": Repeated(Image(extension="JPG"))}, outputs={ "prediction": Repeated(Label(path=str(CWD / "imagenet_labels.txt"))), "other": Number(), }, ) def classify(self, img): img = img[0].float() / 255 mean = torch.tensor([[[0.485, 0.456, 0.406]]]).float() std = torch.tensor([[[0.229, 0.224, 0.225]]]).float() img = (img - mean) / std img = img.permute(0, 3, 2, 1) out = self.model(img) return ([out.argmax(), out.argmax()], torch.Tensor([21]))
def test_deserialize(): num = Number() assert num.deserialize(1).shape == torch.Size([1, 1]) assert torch.allclose(num.deserialize(1), torch.tensor([[1]])) assert num.deserialize(1).dtype == torch.int64 assert num.deserialize(2.0).dtype == torch.float32