Skip to content

Models

rationai.resources.models.Models

Bases: APIResource

Source code in rationai/resources/models.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
class Models(APIResource):
    def classify_image(
        self,
        model: str,
        image: Image | NDArray[np.uint8],
        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
    ) -> float | dict[str, float]:
        """Classify an image using the specified model.

        Args:
            model: The name of the model to use for classification.
            image: The image to classify. It must be uint8 RGB image.
            timeout: Optional timeout for the request.

        Returns:
            (float | dict[str, float]): The classification result as a single float
                (for binary classification) or probabilities for each class.
        """
        data = image.tobytes()
        compressed_data = lz4.frame.compress(data)
        response = self._post(model, data=compressed_data, timeout=timeout)
        response.raise_for_status()
        return response.json()

    def segment_image(
        self,
        model: str,
        image: Image | NDArray[np.uint8],
        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
    ) -> NDArray[np.float16]:
        """Segment an image using the specified model.

        Args:
            model: The name of the model to use for segmentation.
            image: The image to segment. It must be uint8 RGB image.
            timeout: Optional timeout for the request.

        Returns:
            NDArray[np.float16]: The segmentation result as a numpy array of float16 values.
                The shape of the array is (num_classes, height, width).
        """
        if isinstance(image, Image):
            w, h = image.size
        else:
            h, w = image.shape[:2]

        data = image.tobytes()
        compressed_data = lz4.frame.compress(data)
        response = self._post(model, data=compressed_data, timeout=timeout)
        response.raise_for_status()

        return np.frombuffer(
            lz4.frame.decompress(response.content), dtype=np.float16
        ).reshape(-1, h, w)

classify_image(model, image, timeout=USE_CLIENT_DEFAULT)

Classify an image using the specified model.

Parameters:

Name Type Description Default
model str

The name of the model to use for classification.

 required
image Image | NDArray[uint8]

The image to classify. It must be uint8 RGB image.

 required
timeout TimeoutTypes | UseClientDefault

Optional timeout for the request.

 USE_CLIENT_DEFAULT

Returns:

Type Description
float | dict[str, float]

The classification result as a single float (for binary classification) or probabilities for each class.
Source code in rationai/resources/models.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def classify_image(
    self,
    model: str,
    image: Image | NDArray[np.uint8],
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
) -> float | dict[str, float]:
    """Classify an image using the specified model.

    Args:
        model: The name of the model to use for classification.
        image: The image to classify. It must be uint8 RGB image.
        timeout: Optional timeout for the request.

    Returns:
        (float | dict[str, float]): The classification result as a single float
            (for binary classification) or probabilities for each class.
    """
    data = image.tobytes()
    compressed_data = lz4.frame.compress(data)
    response = self._post(model, data=compressed_data, timeout=timeout)
    response.raise_for_status()
    return response.json()

segment_image(model, image, timeout=USE_CLIENT_DEFAULT)

Segment an image using the specified model.

Parameters:

Name Type Description Default
model str

The name of the model to use for segmentation.

 required
image Image | NDArray[uint8]

The image to segment. It must be uint8 RGB image.

 required
timeout TimeoutTypes | UseClientDefault

Optional timeout for the request.

 USE_CLIENT_DEFAULT

Returns:

Type Description
NDArray[float16]

NDArray[np.float16]: The segmentation result as a numpy array of float16 values. The shape of the array is (num_classes, height, width).
Source code in rationai/resources/models.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def segment_image(
    self,
    model: str,
    image: Image | NDArray[np.uint8],
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
) -> NDArray[np.float16]:
    """Segment an image using the specified model.

    Args:
        model: The name of the model to use for segmentation.
        image: The image to segment. It must be uint8 RGB image.
        timeout: Optional timeout for the request.

    Returns:
        NDArray[np.float16]: The segmentation result as a numpy array of float16 values.
            The shape of the array is (num_classes, height, width).
    """
    if isinstance(image, Image):
        w, h = image.size
    else:
        h, w = image.shape[:2]

    data = image.tobytes()
    compressed_data = lz4.frame.compress(data)
    response = self._post(model, data=compressed_data, timeout=timeout)
    response.raise_for_status()

    return np.frombuffer(
        lz4.frame.decompress(response.content), dtype=np.float16
    ).reshape(-1, h, w)

rationai.resources.models.AsyncModels

Bases: AsyncAPIResource

Source code in rationai/resources/models.py 
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
class AsyncModels(AsyncAPIResource):
    async def classify_image(
        self,
        model: str,
        image: Image | NDArray[np.uint8],
        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
    ) -> float | dict[str, float]:
        """Classify an image using the specified model.

        Args:
            model: The name of the model to use for classification.
            image: The image to classify. It must be uint8 RGB image.
            timeout: Optional timeout for the request.

        Returns:
            (float | dict[str, float]): The classification result as a single float
                (for binary classification) or probabilities for each class.
        """
        data = image.tobytes()
        compressed_data = lz4.frame.compress(data)
        response = await self._post(model, data=compressed_data, timeout=timeout)
        response.raise_for_status()
        return response.json()

    async def segment_image(
        self,
        model: str,
        image: Image | NDArray[np.uint8],
        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
    ) -> NDArray[np.float16]:
        """Segment an image using the specified model.

        Args:
            model: The name of the model to use for segmentation.
            image: The image to segment. It must be uint8 RGB image.
            timeout: Optional timeout for the request.

        Returns:
            NDArray[np.float16]: The segmentation result as a numpy array of float16 values.
                The shape of the array is (num_classes, height, width).
        """
        if isinstance(image, Image):
            w, h = image.size
        else:
            h, w = image.shape[:2]

        data = image.tobytes()
        compressed_data = lz4.frame.compress(data)
        response = await self._post(model, data=compressed_data, timeout=timeout)
        response.raise_for_status()

        return np.frombuffer(
            lz4.frame.decompress(response.content), dtype=np.float16
        ).reshape(-1, h, w)

classify_image(model, image, timeout=USE_CLIENT_DEFAULT) async

Classify an image using the specified model.

Parameters:

Name Type Description Default
model str

The name of the model to use for classification.

 required
image Image | NDArray[uint8]

The image to classify. It must be uint8 RGB image.

 required
timeout TimeoutTypes | UseClientDefault

Optional timeout for the request.

 USE_CLIENT_DEFAULT

Returns:

Type Description
float | dict[str, float]

The classification result as a single float (for binary classification) or probabilities for each class.
Source code in rationai/resources/models.py 
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
async def classify_image(
    self,
    model: str,
    image: Image | NDArray[np.uint8],
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
) -> float | dict[str, float]:
    """Classify an image using the specified model.

    Args:
        model: The name of the model to use for classification.
        image: The image to classify. It must be uint8 RGB image.
        timeout: Optional timeout for the request.

    Returns:
        (float | dict[str, float]): The classification result as a single float
            (for binary classification) or probabilities for each class.
    """
    data = image.tobytes()
    compressed_data = lz4.frame.compress(data)
    response = await self._post(model, data=compressed_data, timeout=timeout)
    response.raise_for_status()
    return response.json()

segment_image(model, image, timeout=USE_CLIENT_DEFAULT) async

Segment an image using the specified model.

Parameters:

Name Type Description Default
model str

The name of the model to use for segmentation.

 required
image Image | NDArray[uint8]

The image to segment. It must be uint8 RGB image.

 required
timeout TimeoutTypes | UseClientDefault

Optional timeout for the request.

 USE_CLIENT_DEFAULT

Returns:

Type Description
NDArray[float16]

NDArray[np.float16]: The segmentation result as a numpy array of float16 values. The shape of the array is (num_classes, height, width).
Source code in rationai/resources/models.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
async def segment_image(
    self,
    model: str,
    image: Image | NDArray[np.uint8],
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
) -> NDArray[np.float16]:
    """Segment an image using the specified model.

    Args:
        model: The name of the model to use for segmentation.
        image: The image to segment. It must be uint8 RGB image.
        timeout: Optional timeout for the request.

    Returns:
        NDArray[np.float16]: The segmentation result as a numpy array of float16 values.
            The shape of the array is (num_classes, height, width).
    """
    if isinstance(image, Image):
        w, h = image.size
    else:
        h, w = image.shape[:2]

    data = image.tobytes()
    compressed_data = lz4.frame.compress(data)
    response = await self._post(model, data=compressed_data, timeout=timeout)
    response.raise_for_status()

    return np.frombuffer(
        lz4.frame.decompress(response.content), dtype=np.float16
    ).reshape(-1, h, w)