prefab 0.4.7__py3-none-any.whl → 1.1.8__py3-none-any.whl

{prefab-0.4.7.dist-info → prefab-1.1.8.dist-info}/METADATA

@@ -1,9 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: prefab
-Version: 0.4.7
-Summary: Machine learning based prediction of photonic device fabrication
-Project-URL: Homepage, https://github.com/PreFab-Photonics/PreFab
-Author-email: Dusan Gostimirovic <dusan@prefabphotonics.com>
+Version: 1.1.8
+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: "PreFab Photonics Inc." <hi@prefabphotonics.com>
 License:                   GNU LESSER GENERAL PUBLIC LICENSE
                                Version 2.1, February 1999
         
@@ -509,54 +511,59 @@ License:                   GNU LESSER GENERAL PUBLIC LICENSE
         
         That's all there is to it!
 License-File: LICENSE
-Keywords: layout,machine learning,nanofabrication,photonics
+Keywords: computer-vision,deep-learning,electronic-design-automation,integrated-photonics,machine-learning,nanofabrication,semiconductor-manufacturing
 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: autograd
+Requires-Dist: gdstk>=0.9.55
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: opencv-python-headless
+Requires-Dist: pillow
+Requires-Dist: pydantic>=2.10
 Requires-Dist: requests
+Requires-Dist: scikit-image
+Requires-Dist: scipy
+Requires-Dist: toml
+Requires-Dist: tqdm
 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 is a _virtual nanofabrication environment_ that leverages **deep learning** and **computer vision** to predict and correct for structural variations in integrated photonic devices during nanofabrication.
+
+> **Try Rosette**: Want a more visual experience? Try [Rosette](https://rosette.dev) - our new layout tool with PreFab models built in, designed for rapid chip design.
 
 ## 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 predicts process-induced structural variations, including corner rounding, loss of small lines and islands, filling of narrow holes and channels, sidewall angle deviations, and stochastic effects. This allows designers to rapidly prototype and evaluate expected performance pre-fabrication.
 
-![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 corrects device designs to ensure that the fabricated outcome closely matches the intended specifications. This minimizes structural variations and reduces performance discrepancies between simulations and actual experiments.
 
-![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`](docs/models.md)):
+Each photonic nanofabrication process requires unique models, which are regularly updated with the latest data. The current models include (see the full list in [`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) | d7 (Nov 24 2023) | ANT_NanoSOI   | v6-d7       | 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  |
+| ------- | ------- | ----------------- | ---------------- | ----------- |
+| ANT     | NanoSOI | ANF1 (May 6 2024) | d10 (Jun 8 2024) | ANT_NanoSOI_ANF1_d10 |
+| ANT     | SiN     | ANF1 (May 6 2024) | d1 (Jan 31 2024) | ANT_SiN_ANF1_d1 |
 
-_New models and foundries are regularly added. Usage may change. For additional foundry and process models, feel free to contact us or raise an issue._
+> _New models are to be regularly added. Usage may change. For additional foundry and process models, feel free to [contact us](mailto:hi@prefabphotonics.com) or raise an issue._
 
 ## Installation
 
-### Local
-
-Install `PreFab` via pip:
+Install PreFab via pip:
 
 ```sh
 pip install prefab
@@ -570,24 +577,30 @@ cd PreFab
 pip install -e .
 ```
 
-### Online
+## Getting Started
 
-Use `PreFab` online through GitHub Codespaces:
+### Account setup
 
-[![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)
+Before you can make PreFab requests, you will need to [create an account](https://www.prefabphotonics.com/login).
 
-## Getting Started
+To link your account, you will need an token. You can do this by running the following command in your terminal. This will open a browser window where you can log in and authenticate your token.
+
+```sh
+python3 -m prefab setup
+```
+
+### Guides
 
-Visit [`/examples`](https://github.com/PreFab-Photonics/PreFab/tree/main/examples) for usage notebooks.
+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 hosted on a [serverless cloud platform](https://modal.com/). Please keep in mind:
 
-- 🐢 CPU inferencing may result in slower performance. Future updates will introduce GPU inferencing.
-- 🥶 The first prediction may take longer due to cold start server loading. Subsequent predictions will be faster.
-- 😊 Be considerate of usage. Start small and limit usage during the initial stages. Thank you!
+- 🐢 Default CPU inference may be slower.
+- 🥶 The first prediction using optional GPU inference may take longer due to cold start server loading. Subsequent predictions will be faster.
+- 😊 Please be considerate of usage. Start with small tasks and limit usage during the initial stages. Thank you!
 
 ## License
 
-This project is licensed under the LGPL-2.1 license. © 2023 PreFab Photonics.
+This project is licensed under the LGPL-2.1 license. © 2024 PreFab Photonics.

prefab-1.1.8.dist-info/RECORD

@@ -0,0 +1,14 @@
+prefab/__init__.py,sha256=V4m0w3VrKeMgeNeqyc_45E5KXH9fVOQKO5xyH42uDmg,425
+prefab/__main__.py,sha256=1eXWiEoG7eetJMm1qRbK2I5MnzuRgKIoQtBeT-Ps8es,3523
+prefab/compare.py,sha256=0Xgp3tFuP4of-ce9Opc19p8i8lIyXkbVGLuwWBaHSeE,3486
+prefab/device.py,sha256=1rqs_VQ7am6W473C-EZTsPFDlqNIMMd26VZAUV1tNS0,54885
+prefab/geometry.py,sha256=4fekWMlkdS_qlPNTdPXPhwKuQ5qdQ1Zjf8m9JKd1dA8,12049
+prefab/models.py,sha256=waPNGtuISyY0f8cz7dnbD451CKYCt8EpPGt-4lSOPNU,2581
+prefab/predict.py,sha256=h13523jasg1WbdiYbkXy43SWTGfQXjq6oEe0O8DT2U0,11731
+prefab/read.py,sha256=WNqC3xENlndzFwXeCF2E7H3Iq2dO_6rPEPZ58DuloqY,16259
+prefab/shapes.py,sha256=58cyXFNh1kEErq2jEbGd3dWSediU1OSmor_FWwc1V8A,25098
+prefab-1.1.8.dist-info/METADATA,sha256=d5ide0FP2wUQALM_2SSFhA_BGU6s3waxWjtXwsbjivs,35036
+prefab-1.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+prefab-1.1.8.dist-info/entry_points.txt,sha256=h1_A9O9F3NAIoKXD1RPb3Eo-WCSiHhMB_AnagBi6XTQ,48
+prefab-1.1.8.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-1.1.8.dist-info/RECORD,,

{prefab-0.4.7.dist-info → prefab-1.1.8.dist-info}/WHEEL

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

prefab-1.1.8.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+prefab = prefab.__main__:main

prefab/io.py

@@ -1,200 +0,0 @@
-"""
-This module offers tools to import, export, and preprocess device layouts in multiple formats for
-nanofabrication prediction tasks.
-"""
-
-from typing import Optional, List, Tuple
-import matplotlib.image as img
-import numpy as np
-import gdstk
-import cv2
-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, 100)
-
-    return device
-
-
-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_CCOMP,
-        approximation_method_mapping[approximation_mode],
-    )
-
-    outer_polygons = []
-    inner_polygons = []
-
-    for idx, contour in enumerate(contours):
-        if len(contour) > 2:
-            contour = contour / 1000  # μm to nm
-            points = [tuple(point) for point in contour.squeeze().tolist()]
-
-            if hierarchy[0][idx][3] == -1:
-                outer_polygons.append(points)
-            else:
-                inner_polygons.append(points)
-
-    polygons = gdstk.boolean(
-        outer_polygons, inner_polygons, "xor", layer=layer[0], datatype=layer[1]
-    )
-    for polygon in polygons:
-        polygon.scale(resolution, resolution)
-
-    cell = library.new_cell(cell_name)
-    for polygon in polygons:
-        cell.add(polygon)
-
-    return cell

prefab/predictor.py

@@ -1,161 +0,0 @@
-"""
-A module for making predictions on fabrication variations in photonic devices 
-using machine learning models deployed in the cloud.
-"""
-
-import base64
-
-import numpy as np
-import requests
-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,
-    }
-
-    prediction = _decode_image(
-        requests.post(function_url, json=predict_data, timeout=200)
-    )
-
-    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,
-    }
-
-    correction = _decode_image(
-        requests.post(function_url, json=correct_data, timeout=200)
-    )
-
-    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.json())
-    decoded_image = np.frombuffer(encoded_image, np.uint8)
-    decoded_image = imdecode(decoded_image, IMREAD_GRAYSCALE) / 255
-    return decoded_image