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
