prefab 0.5.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

{prefab-0.5.1.dist-info → prefab-1.0.0.dist-info}/METADATA

@@ -1,8 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: prefab
-Version: 0.5.1
-Summary: Machine learning based prediction of photonic device fabrication
-Project-URL: Homepage, https://github.com/PreFab-Photonics/PreFab
+Version: 1.0.0
+Summary: Artificial nanofabrication of integrated photonic circuits using deep learning
+Project-URL: Homepage, https://prefabphotonics.com
+Project-URL: Repository, https://github.com/PreFab-Photonics/PreFab
+Project-URL: Docs, https://docs.prefabphotonics.com
 Author-email: Dusan Gostimirovic <dusan@prefabphotonics.com>
 License:                   GNU LESSER GENERAL PUBLIC LICENSE
                                Version 2.1, February 1999
@@ -509,54 +511,52 @@ License:                   GNU LESSER GENERAL PUBLIC LICENSE
         
         That's all there is to it!
 License-File: LICENSE
-Keywords: layout,machine learning,nanofabrication,photonics
+Keywords: machine-learning,nanofabrication,photonics
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-Requires-Dist: gdspy
+Requires-Dist: gdstk
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: opencv-python-headless
+Requires-Dist: pydantic
 Requires-Dist: requests
+Requires-Dist: toml
 Description-Content-Type: text/markdown
 
 # PreFab
 
-![PreFab logo](https://github.com/PreFab-Photonics/PreFab/blob/main/assets/logo.png?raw=true)
+![PreFab logo](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/logo.png?raw=true)
 
-`PreFab` leverages **deep learning** to model fabrication-induced structural variations in integrated photonic devices. Through this _virtual nanofabrication environment_, we uncover valuable insights into nanofabrication processes and enhance device design accuracy.
+PreFab leverages **deep learning** to model fabrication-induced structural variations in integrated photonic devices. Through this _virtual nanofabrication environment_, we uncover valuable insights into nanofabrication processes and enhance device design accuracy.
 
 ## Prediction
 
-`PreFab` accurately predicts process-induced structural alterations such as corner rounding, washing away of small lines and islands, and filling of narrow holes in planar photonic devices. This enables designers to quickly prototype expected performance and rectify designs prior to nanofabrication.
+PreFab accurately predicts process-induced structural alterations such as corner rounding, washing away of small lines and islands, and filling of narrow holes in planar photonic devices. This enables designers to quickly prototype expected performance and rectify designs prior to nanofabrication.
 
-![Example of PreFab prediction](https://github.com/PreFab-Photonics/PreFab/blob/main/assets/promo_p.png?raw=true)
+![Example of PreFab prediction](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/promo_p.png?raw=true)
 
 ## Correction
 
-`PreFab` automates corrections to device designs, ensuring the fabricated outcome aligns with the original design. This results in reduced structural variation and performance disparity from simulation to experiment.
+PreFab automates corrections to device designs, ensuring the fabricated outcome aligns with the original design. This results in reduced structural variation and performance disparity from simulation to experiment.
 
-![Example of PreFab correction](https://github.com/PreFab-Photonics/PreFab/blob/main/assets/promo_c.png?raw=true)
+![Example of PreFab correction](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/assets/promo_c.png?raw=true)
 
 ## Models
 
-`PreFab` accommodates unique _predictor_ and _corrector_ models for each photonic foundry, regularly updated based on recent fabrication data. Current models include (see full list on [`docs/models.md`](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/models.md)):
+PreFab accommodates unique _predictor_ and _corrector_ models for each photonic foundry, regularly updated based on recent fabrication data. Current models include (see full list on [`docs/models.md`](https://github.com/PreFab-Photonics/PreFab/blob/main/docs/models.md)):
 
-| Foundry   | Process                                                                            | Latest Version   | Latest Dataset   | Model Name    | Model Tag   | Status |
-| --------- | ---------------------------------------------------------------------------------- | ---------------- | ---------------- | ------------- | ----------- | ------ |
-| ANT       | [NanoSOI](https://www.appliednt.com/nanosoi-fabrication-service/)                  | v6 (Nov 24 2023) | d8 (Feb 6 2023)  | ANT_NanoSOI   | v6-d8       | Beta   |
-| ANT       | [SiN (Upper Edge)](https://www.appliednt.com/nanosoi/sys/resources/specs_nitride/) | v5 (Jun 3 2023)  | d0 (Jun 1 2023)  | ANT_SiN       | v5-d0-upper | Alpha  |
-| ANT       | [SiN (Lower Edge)](https://www.appliednt.com/nanosoi/sys/resources/specs_nitride/) | v5 (Jun 3 2023)  | d0 (Jun 1 2023)  | ANT_SiN       | v5-d0-lower | Alpha  |
-| SiEPICfab | [SOI](https://siepic.ca/fabrication/)                                              | v5 (Jun 3 2023)  | d0 (Jun 14 2023) | SiEPICfab_SOI | v5-d0       | Alpha  |
+| Foundry | Process | Latest Version    | Latest Dataset   | Model Name  | Model Tag |
+| ------- | ------- | ----------------- | ---------------- | ----------- | --------- |
+| ANT     | NanoSOI | ANF1 (May 6 2023) | d9 (Feb 6 2024)  | ANT_NanoSOI | ANF1-d9   |
+| ANT     | SiN     | ANF1 (May 6 2023) | d1 (Jan 31 2024) | ANT_SiN     | ANF1-d1   |
 
-_New models and foundries are to be added. Usage may change. For additional foundry and process models, feel free to contact us or raise an issue._
+> _New models and foundries are to be regularly added. Usage may change. For additional foundry and process models, feel free to contact us._
 
 ## Installation
 
-### Local
-
-Install `PreFab` via pip:
+Install PreFab via pip:
 
 ```sh
 pip install prefab
@@ -570,12 +570,6 @@ cd PreFab
 pip install -e .
 ```
 
-### Online
-
-Use `PreFab` online through GitHub Codespaces:
-
-[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://github.com/codespaces/new?machine=basicLinux32gb&repo=608330448&ref=main&devcontainer_path=.devcontainer%2Fdevcontainer.json&location=EastUs)
-
 ## Getting Started
 
 ### Account setup
@@ -590,11 +584,11 @@ python3 -m prefab setup
 
 ### Guides
 
-Visit [`/examples`](https://github.com/PreFab-Photonics/PreFab/tree/main/examples) or our [Guides](https://www.prefabphotonics.com/docs/guides/predictions) to get started with your first predictions.
+Visit [`/docs/examples`](https://github.com/PreFab-Photonics/PreFab/tree/main/docs/examples) or our [docs](https://docs.prefabphotonics.com/) to get started with your first predictions.
 
 ## Performance and Usage
 
-`PreFab` models are served via a serverless cloud platform. Please note:
+PreFab models are served via a serverless cloud platform. Please note:
 
 - 🐢 CPU inference may result in slower performance. Future updates will introduce GPU inference.
 - 🥶 The first prediction may take longer due to cold start server loading. Subsequent predictions will be faster.

prefab-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+prefab/__init__.py,sha256=z9DWthyzmj_EuBt7ywbT3G-lnMmUl4haRYgizvVhlYw,337
+prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
+prefab/compare.py,sha256=EIUQnCjZWMPTc_hibz2UsKCGLEciSJTXFttPQrW3V9o,2369
+prefab/device.py,sha256=UZyz_85mmvIXfjT0Uz22MHW7vDHXR8pr9TkNuvQo_cE,47173
+prefab/geometry.py,sha256=fMQlSJ1fIUUSHBJ1ILk-ATvnOFreK8BLRPWcVbLNkLU,9395
+prefab/models.py,sha256=iVObzxOPct6nnNBNyYM2uk7Jr8w7mRY4ndxvr9Iby8Y,2576
+prefab/read.py,sha256=dGd8-O5-xC5B_dB_VC4E2XLlDt5wIGCU0-VNP-04R94,10116
+prefab-1.0.0.dist-info/METADATA,sha256=JGtW2yaBKey1JlCZ7BxdJqTRtCO-AHB3bA_nGiwXPWE,34674
+prefab-1.0.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+prefab-1.0.0.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-1.0.0.dist-info/RECORD,,

{prefab-0.5.1.dist-info → prefab-1.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.21.1
+Generator: hatchling 1.24.2
 Root-Is-Purelib: true
 Tag: py3-none-any

prefab/io.py

@@ -1,214 +0,0 @@
-"""
-This module offers tools to import, export, and preprocess device layouts in multiple formats for
-nanofabrication prediction tasks.
-"""
-
-from typing import List, Optional, Tuple
-
-import cv2
-import gdstk
-import matplotlib.image as img
-import numpy as np
-
-from prefab.processor import binarize_hard
-
-
-def load_device_img(path: str, img_length_nm: int = None) -> np.ndarray:
-    """
-    Load, process and scale device image from file for prediction.
-
-    This function reads an image file, scales it according to the provided image length in
-    nanometers, and performs preprocessing tasks such as binarization, preparing it for prediction.
-
-    Parameters
-    ----------
-    path : str
-        Path to the device image file.
-
-    img_length_nm : int, optional
-        Desired length of the device image in nanometers for scaling. If not provided,
-        the length of the original image is used.
-
-    Returns
-    -------
-    np.ndarray
-        A 2D numpy array representing the preprocessed and scaled device, ready for prediction.
-    """
-    device = img.imread(path)[:, :, 1]
-    if img_length_nm is None:
-        img_length_nm = device.shape[1]
-    scale = img_length_nm / device.shape[1]
-    device = cv2.resize(device, (0, 0), fx=scale, fy=scale)
-    device = binarize_hard(device)
-    return device
-
-
-def load_device_gds(
-    path: str,
-    cell_name: str,
-    coords: Optional[List[List[int]]] = None,
-    layer: Tuple[int, int] = (1, 0),
-) -> np.ndarray:
-    """
-    Load and process a device layout from a GDSII file.
-
-    This function reads a device layout from a GDSII file, performs necessary
-    preprocessing tasks such as scaling and padding, and prepares it for prediction.
-    Only the specified layer is loaded.
-
-    Parameters
-    ----------
-    path : str
-        Path to the GDSII layout file.
-
-    cell_name : str
-        Name of the GDSII cell to be loaded.
-
-    coords : List[List[int]], optional
-        A list of coordinates [[xmin, ymin], [xmax, ymax]] in nm, defining the
-        region of the cell to be loaded. If None, the entire cell is loaded.
-
-    layer : Tuple[int, int], optional
-        A tuple specifying the layer to be loaded. Default is (1, 0).
-
-    Returns
-    -------
-    np.ndarray
-        A 2D numpy array representing the preprocessed device layout, ready for prediction.
-    """
-    gds = gdstk.read_gds(path)
-    cell = gds[cell_name]
-    polygons = cell.get_polygons(layer=layer[0], datatype=layer[1])
-    bounds = tuple(
-        tuple(1000 * x for x in sub_tuple) for sub_tuple in cell.bounding_box()
-    )
-    device = np.zeros(
-        (int(bounds[1][1] - bounds[0][1]), int(bounds[1][0] - bounds[0][0]))
-    )
-
-    contours = [
-        np.array(
-            [
-                [
-                    [
-                        int(1000 * vertex[0] - bounds[0][0]),
-                        int(1000 * vertex[1] - bounds[0][1]),
-                    ]
-                ]
-                for vertex in polygon.points
-            ],
-            dtype=np.int32,
-        )
-        for polygon in polygons
-    ]
-
-    cv2.fillPoly(img=device, pts=contours, color=(1, 1, 1))
-
-    if coords is not None:
-        new_device = np.zeros(
-            (int(bounds[1][1] - bounds[0][1]), int(bounds[1][0] - bounds[0][0]))
-        )
-        new_device[
-            int(coords[0][1] - bounds[0][1]) : int(coords[1][1] - bounds[0][1]),
-            int(coords[0][0] - bounds[0][0]) : int(coords[1][0] - bounds[0][0]),
-        ] = device[
-            int(coords[0][1] - bounds[0][1]) : int(coords[1][1] - bounds[0][1]),
-            int(coords[0][0] - bounds[0][0]) : int(coords[1][0] - bounds[0][0]),
-        ]
-        device = new_device
-
-    device = np.flipud(device)
-    device = np.pad(device, 200)
-
-    return device.astype(np.float32)
-
-
-def device_to_cell(
-    device: np.ndarray,
-    cell_name: str,
-    library: gdstk.Library,
-    resolution: float = 1.0,
-    layer: Tuple[int, int] = (1, 0),
-    approximation_mode: int = 2,
-) -> gdstk.Cell:
-    """Converts a device layout to a gdstk cell for GDSII export.
-
-    This function creates a cell that represents a device layout. The created cell
-    is ready to be exported as a GDSII file.
-
-    Parameters
-    ----------
-    device : np.ndarray
-        A 2D numpy array representing the device layout.
-
-    cell_name : str
-        Name for the new cell.
-
-    library : gdstk.Library
-        Library to which the cell will be added.
-
-    resolution : float, optional
-        The resolution of the device in pixels per nm. Default is 1.0.
-
-    layer : Tuple[int, int], optional
-        A tuple specifying the layer to be exported. Default is (1, 0).
-
-    approximation_mode : int, optional
-        The approximation method to be used for finding contours. Possible values are 1, 2, 3, and
-        4. Larger values mean more approximation. Default is 1.
-
-    Returns
-    -------
-    gdstk.Cell
-        The newly created cell containing the device layout.
-    """
-    approximation_method_mapping = {
-        1: cv2.CHAIN_APPROX_NONE,
-        2: cv2.CHAIN_APPROX_SIMPLE,
-        3: cv2.CHAIN_APPROX_TC89_L1,
-        4: cv2.CHAIN_APPROX_TC89_KCOS,
-    }
-
-    device = np.flipud(device)
-    contours, hierarchy = cv2.findContours(
-        device.astype(np.uint8),
-        cv2.RETR_TREE,
-        approximation_method_mapping[approximation_mode],
-    )
-
-    hierarchy_polygons = {}
-
-    for idx, contour in enumerate(contours):
-        level = 0
-        current_idx = idx
-        while hierarchy[0][current_idx][3] != -1:
-            level += 1
-            current_idx = hierarchy[0][current_idx][3]
-
-        if len(contour) > 2:
-            contour = contour / 1000  # μm to nm
-            points = [tuple(point) for point in contour.squeeze().tolist()]
-            if level not in hierarchy_polygons:
-                hierarchy_polygons[level] = []
-            hierarchy_polygons[level].append(points)
-
-    cell = library.new_cell(cell_name)
-    processed_polygons = []
-    # Process polygons by hierarchy level, alternating between adding and XORing
-    for level in sorted(hierarchy_polygons.keys()):
-        operation = "or" if level % 2 == 0 else "xor"
-        polygons_to_process = hierarchy_polygons[level]
-
-        if polygons_to_process:
-            processed_polygons = gdstk.boolean(
-                polygons_to_process,
-                processed_polygons,
-                operation,
-                layer=layer[0],
-                datatype=layer[1],
-            )
-    for polygon in processed_polygons:
-        polygon.scale(resolution, resolution)
-        cell.add(polygon)
-
-    return cell

prefab/predictor.py

@@ -1,231 +0,0 @@
-"""
-A module for making predictions on fabrication variations in photonic devices 
-using machine learning models deployed in the cloud.
-"""
-
-import base64
-import os
-
-import numpy as np
-import requests
-import toml
-from cv2 import IMREAD_GRAYSCALE, imdecode, imencode
-
-from prefab.processor import binarize_hard
-
-
-def predict(
-    device: np.ndarray, model_name: str, model_tags: str, binarize: bool = False
-) -> np.ndarray:
-    """
-    Generates a prediction for a photonic device using a specified cloud-based ML model.
-
-    The function sends an image of the device to a cloud function, which uses the specified
-    machine learning model to generate a prediction.
-
-    Parameters
-    ----------
-    device : np.ndarray
-        A binary numpy matrix representing the shape of a device.
-
-    model_name : str
-        The name of the ML model to use for the prediction.
-        Consult the module's documentation for available models.
-
-    model_tags : Union[str, List[str]]
-        The tags of the ML model.
-        Consult the module's documentation for available tags.
-
-    binarize : bool, optional
-        If set to True, the prediction will be binarized (default is False).
-
-    Returns
-    -------
-    np.ndarray
-        A numpy matrix representing the predicted shape of the device. Pixel values closer
-        to 1 indicate a higher likelihood of core material, while pixel values closer to 0
-        suggest a higher likelihood of cladding material. Pixel values in between represent
-        prediction uncertainty.
-    """
-    function_url = "https://prefab-photonics--predict.modal.run"
-
-    predict_data = {
-        "device": _encode_image(device),
-        "model_name": model_name,
-        "model_tags": model_tags,
-        "binary": binarize,
-    }
-
-    with open(os.path.expanduser("~/.prefab.toml"), "r") as file:
-        content = file.readlines()
-        for line in content:
-            if "access_token" in line:
-                access_token = line.split("=")[1].strip().strip('"')
-            if "refresh_token" in line:
-                refresh_token = line.split("=")[1].strip().strip('"')
-                break
-
-    headers = {
-        "Authorization": f"Bearer {access_token}",
-        "X-Refresh-Token": refresh_token,
-    }
-    response = requests.post(
-        url=function_url,
-        json=predict_data,
-        headers=headers,
-    )
-
-    if response.status_code != 200:
-        raise ValueError(response.text)
-    else:
-        response_data = response.json()
-        if "error" in response_data:
-            raise ValueError(response_data["error"])
-        if "prediction" in response_data:
-            prediction = _decode_image(response_data["prediction"])
-        if "new_refresh_token" in response_data:
-            prefab_file_path = os.path.expanduser("~/.prefab.toml")
-            with open(prefab_file_path, "w", encoding="utf-8") as toml_file:
-                toml.dump(
-                    {
-                        "access_token": response_data["new_access_token"],
-                        "refresh_token": response_data["new_refresh_token"],
-                    },
-                    toml_file,
-                )
-
-    if binarize:
-        prediction = binarize_hard(prediction)
-
-    return prediction
-
-
-def correct(
-    device: np.ndarray,
-    model_name: str,
-    model_tags: str,
-    binarize: bool = True,
-    multi_correct: bool = False,
-) -> np.ndarray:
-    """
-    Generates a correction for a photonic device using a specified cloud-based ML model.
-
-    The function sends an image of the device to a cloud function, which uses the specified
-    machine learning model to generate a correction.
-
-    Parameters
-    ----------
-    device : np.ndarray
-        A binary numpy matrix representing the shape of a device.
-
-    model_name : str
-        The name of the ML model to use for the correction.
-        Consult the module's documentation for available models.
-
-    model_tags : Union[str, List[str]]
-        The tags of the ML model.
-        Consult the module's documentation for available tags.
-
-    binarize : bool, optional
-        If set to True, the correction will be binarized (default is True).
-
-    multi_correct : bool, optional
-        If set to True, the correction will be generated using a iterative approach.
-        (default is False).
-
-    Returns
-    -------
-    np.ndarray
-        A numpy matrix representing the corrected shape of the device. Pixel values closer
-        to 1 indicate a higher likelihood of core material, while pixel values closer to 0
-        suggest a higher likelihood of cladding material. Pixel values in between represent
-        correction uncertainty.
-    """
-    function_url = "https://prefab-photonics--correct.modal.run"
-
-    correct_data = {
-        "device": _encode_image(device),
-        "model_name": model_name,
-        "model_tags": model_tags,
-        "binary": binarize,
-        "multi_correct": multi_correct,
-    }
-
-    with open(os.path.expanduser("~/.prefab.toml"), "r") as file:
-        content = file.readlines()
-        for line in content:
-            if "access_token" in line:
-                access_token = line.split("=")[1].strip().strip('"')
-            if "refresh_token" in line:
-                refresh_token = line.split("=")[1].strip().strip('"')
-                break
-
-    headers = {
-        "Authorization": f"Bearer {access_token}",
-        "X-Refresh-Token": refresh_token,
-    }
-    response = requests.post(
-        url=function_url,
-        json=correct_data,
-        headers=headers,
-    )
-
-    if response.status_code != 200:
-        raise ValueError(response.text)
-    else:
-        response_data = response.json()
-        if "error" in response_data:
-            raise ValueError(response_data["error"])
-        if "correction" in response_data:
-            correction = _decode_image(response_data["correction"])
-        if "new_refresh_token" in response_data:
-            prefab_file_path = os.path.expanduser("~/.prefab.toml")
-            with open(prefab_file_path, "w", encoding="utf-8") as toml_file:
-                toml.dump(
-                    {
-                        "access_token": response_data["new_access_token"],
-                        "refresh_token": response_data["new_refresh_token"],
-                    },
-                    toml_file,
-                )
-
-    return correction
-
-
-def _encode_image(image: np.ndarray) -> str:
-    """
-    Encodes a numpy image array to its base64 representation.
-
-    Parameters
-    ----------
-    image : np.ndarray
-        The image in numpy array format.
-
-    Returns
-    -------
-    str
-        The base64 encoded string of the image.
-    """
-    encoded_image = imencode(".png", 255 * image)[1].tobytes()
-    encoded_image_base64 = base64.b64encode(encoded_image).decode("utf-8")
-    return encoded_image_base64
-
-
-def _decode_image(encoded_image_base64: str) -> np.ndarray:
-    """
-    Decodes a base64 encoded image to its numpy array representation.
-
-    Parameters
-    ----------
-    encoded_image_base64 : str
-        The base64 encoded string of the image.
-
-    Returns
-    -------
-    np.ndarray
-        The decoded image in numpy array format.
-    """
-    encoded_image = base64.b64decode(encoded_image_base64)
-    decoded_image = np.frombuffer(encoded_image, np.uint8)
-    decoded_image = imdecode(decoded_image, IMREAD_GRAYSCALE) / 255
-    return decoded_image