Zj oSrSSKJr SSKrSSKJr SSKJr SSK J r J r J r SSK JrJrJrJr SS KJr \R("\5r\"5(aSSKrS rS rS rS rSrSrSr\"SS9\"SS\555rS/r g)z Processor class for SAM3. )deepcopyN) ImageInput)ProcessorMixin) BatchEncodingPreTokenizedInput TextInput) TensorTypeauto_docstringis_torch_availablelogging)requirescURS5upp4USU-- USU-- USU--USU--/n[R"USS9$N?dimunbindtorchstackxx_cy_cwhbs y/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/transformers/models/sam3/processing_sam3.pybox_cxcywh_to_xyxyr!#sRXXb\NCa a-3q=C#'MS37]LA ;;qb !!cvURS5upp4USU-- USU-- X4/n[R"USS9$rrrs r box_cxcywh_to_xywhr$)s@XXb\NCa a-3q=A4A ;;qb !!r"cfURS5upp#XX-X-/n[R"USS9$Nrrrryrrrs r box_xywh_to_xyxyr)/4"JA! AEQU$A ;;qb !!r"cvURS5upp#USU--USU--X#/n[R"USS9$rrr's r box_xywh_to_cxcywhr,5s@"JA! cAg+S1W0A ;;qb !!r"cfURS5upp#XX - X1- /n[R"USS9$r&r)rr(XYrs r box_xyxy_to_xywhr0;r*r"c|URS5upp4X-S- X$-S- X1- XB- /n[R"USS9$)Nrrr)rx0y0x1y1rs r box_xyxy_to_cxcywhr7AsBXXb\NBB 'QA 27[TU]"X40UD6 X@lUbX0lgURRSUlg)z target_size (`int`, *optional*): The target size (target_size, target_size) to which the image will be resized. point_pad_value (`int`, *optional*, defaults to -10): The value used for padding input boxes. Nheight)super__init__r@image_processorsizer?)selfrE tokenizerr?r@kwargs __class__s r rDSam3Processor.__init__XsA >v>.*5*A;tG[G[G`G`aiGjr"imagestextsegmentation_maps input_boxesinput_boxes_labelsoriginal_sizesreturn_tensorsreturnc Sn UbUR"U4UUS.UD6n O[UbJ[U[R5(aUR 5R 5n[ SU0US9n OUb [S5eURX$5nUb(URX'SSS9n U bU RU 5 OU n UGb=U SnURUS S S S S 9n URUSSSS9n U bU cURU 5n U bURU 5SSn U bURU 5SSnU bU bW W:wa [S5eU biURU W S /-5n[R"U[R S9nUR#UUSSS9 [%U5nU RSU05 U bHURU W5n[R"U[R&S9nU RSU05 U $)a images (`ImageInput`, *optional*): The image(s) to process. text (`str`, `list[str]`, `list[list[str]]`, *optional*): The text to process. segmentation_maps (`ImageInput`, *optional*): The segmentation maps to process. input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *optional*): The bounding boxes to process. input_boxes_labels (`list[list[int]]`, `torch.Tensor`, *optional*): The labels for the bounding boxes. original_sizes (`list[list[float]]`, `torch.Tensor`, *optional*): The original sizes of the images. Returns: A [`BatchEncoding`] with the following fields: - `pixel_values` (`torch.Tensor`): The processed image(s). - `original_sizes` (`list[list[float]]`): The original sizes of the images. - `labels` (`torch.Tensor`): The processed segmentation maps (if provided). - `input_boxes_labels` (`torch.Tensor`): The processed labels for the bounding boxes. - `input_boxes` (`torch.Tensor`): The processed bounding boxes. N)rNrRrQ) tensor_typezKEither images or original_sizes must be provided if input_boxes is not None max_length )rRpaddingrVrr9z)[image level, box level, box coordinates])expected_depth input_nameexpected_formatexpected_coord_sizer2labelsz[image level, box level])rZr[r\zaInput boxes and labels have inconsistent dimensions. Please ensure they have the same dimensions.)dtypeT)is_bounding_boxpreserve_paddingrOrP)rE isinstancerTensorcputolistr ValueError_resolve_text_promptsrHupdate_validate_single_input_generate_default_box_labels_get_nested_dimensions_pad_nested_listtensorfloat32_normalize_tensor_coordinatesr7int64)rGrLrMrNrOrPrQrRrIencoding text_inputsprocessed_boxesprocessed_boxes_labelsboxes_max_dimsboxes_labels_max_dims padded_boxes final_boxespadded_boxes_labelsfinal_boxes_labelss r __call__Sam3Processor.__call__eslD  ++"3- H  '.%,,77!/!3!3!5!$&6%GUcdH  $jk k))$<  ..Vboq.rK# ,&  "%&67N"99 " K$% :O&*%@%@" # : &A& "*/E/M)-)J)J?)[&*!%!>}X""k@R#S@R1HX$6@R#ST 3{+a/ /3{+,>)$/0A0C$DM%)%H%H%bKN 55%)%:%:;>;hiXikt%uKN -#$c $Ts F4F9c[U5S:Xa U/US-$[US5Vs/sHo0RUSSU5PM sn$s snf)z Create an empty nested structure with given dimensions filled with pad_value. Args: dims (`list`): The dimensions of the nested structure. pad_value (`int`): The value to fill the structure with. r~rN)rrr)rGdimsrrs r r,Sam3Processor._create_empty_nested_structuresX t9>;a( (V[\`ab\cVdeVdQR77QR)LVde eesA c[U[5(a3[U5S:XagUHnUcMSURU5-s $ g[U[R [ R45(a[UR5$g)z Get the nesting level of a list structure, skipping None values. Args: input_list (`list`): The list to get the nesting level of. rr~) rbrr_get_nesting_levelrrrrcr)rG input_listrs r r Sam3Processor._get_nesting_levelsy j$ ' ':!#"#t66t<<<#  RZZ$> ? ?z''( (r"rrZr[r\r]c Ucg[U[R[R45(a{UR U:wa"[ SUSUSUSUR S3 5eUb5URSU:wa"[ SUSUSURSS 35eURX5$[U[5(a?URU5nXb:wa[ SUS US USUS 3 5eURX5$g) aW Validate a single input by ensuring proper nesting and raising an error if the input is not valid. Args: data (`torch.Tensor`, `np.ndarray`, or `list`): Input data to process. expected_depth (`int`): Expected nesting depth. input_name (`str`): Name of the input for error messages. expected_format (`str`): The expected format of the input. expected_coord_size (`int`, *optional*): Expected coordinate size (4 for boxes, None for labels). . NzInput z must be a tensor/array with z, dimensions. The expected nesting format is z. Got z dimensions.rz as the last dimension, got .z must be a nested list with z( levels. The expected nesting format is z levels.) rbrrcrrndimrfrrrr)rGrrZr[r\r]rs r ri$Sam3Processor._validate_single_inputs0 < dU\\2::6 7 7yyN* ZL(EnEUVBCRBSSYZ^ZcZcYddpq%0::b>%88$  ,IJ]I^^z{|F|FGI|J{KKLM//E E dD ! ! 33D9M. ZL(D^DTT|~M}NNTUbTcckl//E E "r"c~U(aXR:gnURSSS9n[[U55HnXqRS:dMU[U5:aX'OUSnUR XXS9n U(a4WUn [ R"U RX5XU5X'M|XU'M g)a Helper method to normalize coordinates in a tensor across multiple images. Args: tensor (`torch.Tensor`): Input tensor with coordinates. original_sizes (`list`): Original image sizes. is_bounding_box (`bool`, *optional*, defaults to `False`): Whether coordinates are bounding boxes. preserve_padding (`bool`, *optional*, defaults to `False`): Whether to preserve padding values (for boxes). rT)rkeepdimr)r`N) r@allrrrrrwhere expand_as) rGrmrQr`ramask coord_maskimg_idxrnormalized_coordsimg_masks r ro+Sam3Processor._normalize_tensor_coordinatess 111Db$7JS01Ga(;BSEX;X 7^lmn^o $($?$?O]%@%!$)'2H&+kk **6?;=NW^P_'FO'87O2r"c:URRXU5$)a Converts the output of [`Sam3Model`] into semantic segmentation maps. Args: outputs ([`Sam3ImageSegmentationOutput`]): Raw outputs of the model containing semantic_seg. target_sizes (`list[tuple]` of length `batch_size`, *optional*): List of tuples corresponding to the requested final size (height, width) of each prediction. If unset, predictions will not be resized. threshold (`float`, *optional*, defaults to 0.5): Threshold for binarizing the semantic segmentation masks. Returns: semantic_segmentation: `list[torch.Tensor]` of length `batch_size`, where each item is a semantic segmentation map of shape (height, width) corresponding to the target_sizes entry (if `target_sizes` is specified). Each entry is a binary mask (0 or 1). )rE"post_process_semantic_segmentation)rGoutputs target_sizes thresholds r r0Sam3Processor.post_process_semantic_segmentations$##FFw^ghhr"c:URRXU5$)a Converts the raw output of [`Sam3Model`] into final bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. This is a convenience wrapper around the image processor method. Args: outputs ([`Sam3ImageSegmentationOutput`]): Raw outputs of the model containing pred_boxes, pred_logits, and optionally presence_logits. threshold (`float`, *optional*, defaults to 0.3): Score threshold to keep object detection predictions. target_sizes (`list[tuple[int, int]]`, *optional*): List of tuples (`tuple[int, int]`) containing the target size `(height, width)` of each image in the batch. If unset, predictions will not be resized. Returns: `list[dict]`: A list of dictionaries, each dictionary containing the following keys: - **scores** (`torch.Tensor`): The confidence scores for each predicted box on the image. - **boxes** (`torch.Tensor`): Image bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. Example: ```python >>> from transformers import AutoModel, AutoProcessor >>> from PIL import Image >>> import httpx >>> from io import BytesIO >>> model = AutoModel.from_pretrained("facebook/sam3-base") >>> processor = AutoProcessor.from_pretrained("facebook/sam3-base") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(images=image, text="cat", return_tensors="pt") >>> outputs = model(**inputs) >>> # Post-process to get bounding boxes >>> results = processor.post_process_object_detection(outputs, threshold=0.3, target_sizes=[image.size[::-1]]) >>> boxes = results[0]["boxes"] >>> scores = results[0]["scores"] ``` )rEpost_process_object_detection)rGrrrs r r+Sam3Processor.post_process_object_detection.sV##AA'Vbccr"c:URRXX45$)a) Converts the raw output of [`Sam3Model`] into instance segmentation predictions with bounding boxes and masks. This is a convenience wrapper around the image processor method. Args: outputs ([`Sam3ImageSegmentationOutput`]): Raw outputs of the model containing pred_boxes, pred_logits, pred_masks, and optionally presence_logits. threshold (`float`, *optional*, defaults to 0.3): Score threshold to keep instance predictions. mask_threshold (`float`, *optional*, defaults to 0.5): Threshold for binarizing the predicted masks. target_sizes (`list[tuple[int, int]]`, *optional*): List of tuples (`tuple[int, int]`) containing the target size `(height, width)` of each image in the batch. If unset, predictions will not be resized. Returns: `list[dict]`: A list of dictionaries, each dictionary containing the following keys: - **scores** (`torch.Tensor`): The confidence scores for each predicted instance on the image. - **boxes** (`torch.Tensor`): Image bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. - **masks** (`torch.Tensor`): Binary segmentation masks for each instance, shape (num_instances, height, width). Example: ```python >>> from transformers import AutoModel, AutoProcessor >>> from PIL import Image >>> import httpx >>> from io import BytesIO >>> model = AutoModel.from_pretrained("facebook/sam3-base") >>> processor = AutoProcessor.from_pretrained("facebook/sam3-base") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(images=image, text="cat", return_tensors="pt") >>> outputs = model(**inputs) >>> # Post-process to get instance segmentation >>> results = processor.post_process_instance_segmentation( ... outputs, threshold=0.3, target_sizes=[image.size[::-1]] ... ) >>> masks = results[0]["masks"] >>> boxes = results[0]["boxes"] >>> scores = results[0]["scores"] ``` )rE"post_process_instance_segmentation)rGrrmask_thresholdrs r r0Sam3Processor.post_process_instance_segmentation[s#r##FF   r")r@r?)Ni)NNNNNNN)F)r torch.TensorrSr)r)N)rN)FF)Nr)333333?N)rrN)#__name__ __module__ __qualname____firstlineno__rrDr rr rrrrrcstrr rr{rrjrrgrkrlrrrrrirorrr__static_attributes__ __classcell__)rJs@r r=r=Usbe k7:Tz k[^ k k%)ae/3EIJNBF26jT!j++d9o=EV@WWZ^^j&, j $tE{+,u||;dB j !d3i1ELL@4G jT%[)ELL84?jj(4/j jjX6l(ET6&P@D f8+/ 0FllRZZ'$.0F0F 0F  0F !4Z 0F 0Fd!8Fi(+d` ; ; r"r=)!__doc__copyrrr image_utilsrprocessing_utilsrtokenization_utils_baserrr utilsr r r r utils.import_utilsr get_loggerrloggerrr!r$r)r,r0r7r:r=__all__r"r rs%.RRLL*   H %" " " " " " ! : N  D  r"