Skip to content

Predict

Provides prediction functions for ndarrays of device geometries.

predict_array(device_array, model, model_type, binarize, gpu=False)

Predict the nanofabrication outcome of a device array using a specified model.

This function sends the device array to a serverless prediction service, which uses a specified machine learning model to predict the outcome of the nanofabrication process. The prediction can be performed on a GPU if specified.

Parameters:

Name Type Description Default
device_array ndarray

A 2D array representing the planar geometry of the device. This array undergoes various transformations to predict the nanofabrication process.

 required
model Model

The model to use for prediction, representing a specific fabrication process and dataset. This model encapsulates details about the fabrication foundry, process, material, technology, thickness, and sidewall presence, as defined in models.py. Each model is associated with a version and dataset that detail its creation and the data it was trained on, ensuring the prediction is tailored to specific fabrication parameters.

 required
model_type str

The type of model to use (e.g., 'p', 'c', 's').

 required
binarize bool

If True, the predicted device geometry will be binarized using a threshold method. This is useful for converting probabilistic predictions into binary geometries.

 required
gpu bool

If True, the prediction will be performed on a GPU. Defaults to False. Note: The GPU option has more overhead and will take longer for small devices, but will be faster for larger devices.

 False

Returns:

Type Description
ndarray

The predicted output array.

Raises:

Type Description
RuntimeError

If the request to the prediction service fails.
Source code in prefab/predict.py 
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def predict_array(
    device_array: np.ndarray,
    model: Model,
    model_type: str,
    binarize: bool,
    gpu: bool = False,
) -> np.ndarray:
    """
    Predict the nanofabrication outcome of a device array using a specified model.

    This function sends the device array to a serverless prediction service, which uses
    a specified machine learning model to predict the outcome of the nanofabrication
    process. The prediction can be performed on a GPU if specified.

    Parameters
    ----------
    device_array : np.ndarray
        A 2D array representing the planar geometry of the device. This array undergoes
        various transformations to predict the nanofabrication process.
    model : Model
        The model to use for prediction, representing a specific fabrication process and
        dataset. This model encapsulates details about the fabrication foundry, process,
        material, technology, thickness, and sidewall presence, as defined in
        `models.py`. Each model is associated with a version and dataset that detail its
        creation and the data it was trained on, ensuring the prediction is tailored to
        specific fabrication parameters.
    model_type : str
        The type of model to use (e.g., 'p', 'c', 's').
    binarize : bool
        If True, the predicted device geometry will be binarized using a threshold
        method. This is useful for converting probabilistic predictions into binary
        geometries.
    gpu : bool, optional
        If True, the prediction will be performed on a GPU. Defaults to False. Note: The
        GPU option has more overhead and will take longer for small devices, but will be
        faster for larger devices.

    Returns
    -------
    np.ndarray
        The predicted output array.

    Raises
    ------
    RuntimeError
        If the request to the prediction service fails.
    """
    headers = _prepare_headers()
    predict_data = _prepare_predict_data(device_array, model, model_type, binarize)
    endpoint_url = f"{BASE_URL}-gpu-v1.modal.run" if gpu else f"{BASE_URL}-v1.modal.run"

    try:
        with requests.post(
            endpoint_url,
            data=json.dumps(predict_data),
            headers=headers,
            stream=True,
        ) as response:
            response.raise_for_status()
            return _process_response(response, model_type, binarize)
    except requests.RequestException as e:
        raise RuntimeError(f"Request failed: {e}") from e

predict_array_with_grad(device_array, model)

Predict the nanofabrication outcome of a device array and compute its gradient.

This function predicts the outcome of the nanofabrication process for a given device array using a specified model. It also computes the gradient of the prediction with respect to the input device array.

Parameters:

Name Type Description Default
device_array ndarray

A 2D array representing the planar geometry of the device.

 required
model Model

The model to use for prediction, representing a specific fabrication process.

 required

Returns:

Type Description
ndarray

The predicted output array.
Source code in prefab/predict.py 
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
@primitive
def predict_array_with_grad(device_array: np.ndarray, model: Model) -> np.ndarray:
    """
    Predict the nanofabrication outcome of a device array and compute its gradient.

    This function predicts the outcome of the nanofabrication process for a given
    device array using a specified model. It also computes the gradient of the
    prediction with respect to the input device array.

    Parameters
    ----------
    device_array : np.ndarray
        A 2D array representing the planar geometry of the device.
    model : Model
        The model to use for prediction, representing a specific fabrication process.

    Returns
    -------
    np.ndarray
        The predicted output array.
    """
    prediction_array, gradient_array = _predict_array_with_grad(
        device_array=device_array, model=model
    )
    predict_array_with_grad.gradient_array = gradient_array
    return prediction_array

predict_array_with_grad_vjp(ans, x, model)

Define the vector-Jacobian product (VJP) for the prediction function.

This function provides the VJP for the predict_array_with_grad function, which is used in reverse-mode automatic differentiation to compute gradients.

Parameters:

Name Type Description Default
ans ndarray

The output of the predict_array_with_grad function.

 required
x ndarray

The input device array for which the gradient is computed.

 required
model Model

The model used for prediction.

 required

Returns:

Type Description
function

A function that computes the VJP given an upstream gradient g.
Source code in prefab/predict.py 
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
def predict_array_with_grad_vjp(ans: np.ndarray, x: np.ndarray, model: Model):
    """
    Define the vector-Jacobian product (VJP) for the prediction function.

    This function provides the VJP for the `predict_array_with_grad` function,
    which is used in reverse-mode automatic differentiation to compute gradients.

    Parameters
    ----------
    ans : np.ndarray
        The output of the `predict_array_with_grad` function.
    x : np.ndarray
        The input device array for which the gradient is computed.
    model : Model
        The model used for prediction.

    Returns
    -------
    function
        A function that computes the VJP given an upstream gradient `g`.
    """
    grad_x = predict_array_with_grad.gradient_array

    def vjp(g: np.ndarray) -> np.ndarray:
        return g * grad_x

    return vjp