





# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import torch

from accelerate import PartialState
from accelerate.utils.operations import broadcast, gather, gather_object, pad_across_processes, reduce




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		Dict:
       return (torch.arange(state.num_processes  ) + 1.0 + (state.num_processes * state.process_index)).to(state.device  )




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		Tuple:
       UpperCamelCase_          =  create_tensor(UpperCamelCase_  )
       UpperCamelCase_          =  gather(UpperCamelCase_  )
       assert gathered_tensor.tolist() == list(range(1					,		state.num_processes**2 + 1  )  )




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		str:
       UpperCamelCase_          =  [state.process_index]
       UpperCamelCase_          =  gather_object(UpperCamelCase_  )
       assert len(UpperCamelCase_  ) == state.num_processes, F'''{gathered_obj}, {len(UpperCamelCase_  )} != {state.num_processes}'''
       assert gathered_obj == list(range(state.num_processes  )  ), F'''{gathered_obj} != {list(range(state.num_processes  )  )}'''




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		str:
       UpperCamelCase_          =  create_tensor(UpperCamelCase_  )
       UpperCamelCase_          =  broadcast(UpperCamelCase_  )
       assert broadcasted_tensor.shape == torch.Size([state.num_processes]  )
       assert broadcasted_tensor.tolist() == list(range(1					,		state.num_processes + 1  )  )




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		Optional[Any]:
       # We need to pad the tensor with one more element if we are the main process
       # to ensure that we can pad
       if state.is_main_process:
              UpperCamelCase_          =  torch.arange(state.num_processes + 1  ).to(state.device  )
       else:
              UpperCamelCase_          =  torch.arange(state.num_processes  ).to(state.device  )
       UpperCamelCase_          =  pad_across_processes(UpperCamelCase_  )
       assert padded_tensor.shape == torch.Size([state.num_processes + 1]  )
       if not state.is_main_process:
              assert padded_tensor.tolist() == list(range(0					,		state.num_processes  )  ) + [0]




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		Optional[Any]:
       # For now runs on only two processes
       if state.num_processes != 2:
              return
       UpperCamelCase_          =  create_tensor(UpperCamelCase_  )
       UpperCamelCase_          =  reduce(UpperCamelCase_					,		"sum"  )
       UpperCamelCase_          =  torch.tensor([4.0, 6]  ).to(state.device  )
       assert torch.allclose(UpperCamelCase_					,		UpperCamelCase_  ), F'''{reduced_tensor} != {truth_tensor}'''




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		Union[str, Any]:
       # For now runs on only two processes
       if state.num_processes != 2:
              return
       UpperCamelCase_          =  create_tensor(UpperCamelCase_  )
       UpperCamelCase_          =  reduce(UpperCamelCase_					,		"mean"  )
       UpperCamelCase_          =  torch.tensor([2.0, 3]  ).to(state.device  )
       assert torch.allclose(UpperCamelCase_					,		UpperCamelCase_  ), F'''{reduced_tensor} != {truth_tensor}'''




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		int:
       # For xla_spawn (TPUs)
       main()




def  lowerCAmelCase_ (							)     ->		Optional[int]:
       UpperCamelCase_          =  PartialState()
       state.print(F'''State: {state}'''  )
       state.print("testing gather"  )
       test_gather(UpperCamelCase_  )
       state.print("testing gather_object"  )
       test_gather_object(UpperCamelCase_  )
       state.print("testing broadcast"  )
       test_broadcast(UpperCamelCase_  )
       state.print("testing pad_across_processes"  )
       test_pad_across_processes(UpperCamelCase_  )
       state.print("testing reduce_sum"  )
       test_reduce_sum(UpperCamelCase_  )
       state.print("testing reduce_mean"  )
       test_reduce_mean(UpperCamelCase_  )


if __name__ == "__main__":
     main()








import numpy as np

# Importing the Keras libraries and packages
import tensorflow as tf
from tensorflow.keras import layers, models

if __name__ == "__main__":
     # Initialising the CNN
     # (Sequential- Building the model layer by layer)
     _UpperCAmelCase        =				models.Sequential()

     # Step 1 - Convolution
     # Here 64,64 is the length & breadth of dataset images and 3 is for the RGB channel
     # (3,3) is the kernel size (filter matrix)
     classifier.add(
         layers.ConvaD(3_2, (3, 3), input_shape=(6_4, 6_4, 3), activation='relu')
     )

     # Step 2 - Pooling
     classifier.add(layers.MaxPoolingaD(pool_size=(2, 2)))

     # Adding a second convolutional layer
     classifier.add(layers.ConvaD(3_2, (3, 3), activation='relu'))
     classifier.add(layers.MaxPoolingaD(pool_size=(2, 2)))

     # Step 3 - Flattening
     classifier.add(layers.Flatten())

     # Step 4 - Full connection
     classifier.add(layers.Dense(units=1_2_8, activation='relu'))
     classifier.add(layers.Dense(units=1, activation='sigmoid'))

     # Compiling the CNN
     classifier.compile(
         optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']
     )

     # Part 2 - Fitting the CNN to the images

     # Load Trained model weights

     # from keras.models import load_model
     # regressor=load_model('cnn.h5')

     _UpperCAmelCase        =				tf.keras.preprocessing.image.ImageDataGenerator(
         rescale=1.0 / 2_5_5, shear_range=0.2, zoom_range=0.2, horizontal_flip=True
     )

     _UpperCAmelCase        =				tf.keras.preprocessing.image.ImageDataGenerator(rescale=1.0 / 2_5_5)

     _UpperCAmelCase        =				train_datagen.flow_from_directory(
         'dataset/training_set', target_size=(6_4, 6_4), batch_size=3_2, class_mode='binary'
     )

     _UpperCAmelCase        =				test_datagen.flow_from_directory(
         'dataset/test_set', target_size=(6_4, 6_4), batch_size=3_2, class_mode='binary'
     )

     classifier.fit_generator(
         training_set, steps_per_epoch=5, epochs=3_0, validation_data=test_set
     )

     classifier.save('cnn.h5')

     # Part 3 - Making new predictions

     _UpperCAmelCase        =				tf.keras.preprocessing.image.load_img(
         'dataset/single_prediction/image.png', target_size=(6_4, 6_4)
     )
     _UpperCAmelCase        =				tf.keras.preprocessing.image.img_to_array(test_image)
     _UpperCAmelCase        =				np.expand_dims(test_image, axis=0)
     _UpperCAmelCase        =				classifier.predict(test_image)
     # training_set.class_indices
     if result[0][0] == 0:
          _UpperCAmelCase        =				'Normal'
     if result[0][0] == 1:
          _UpperCAmelCase        =				'Abnormality detected'

