Question

give me the code to make

Before getting started, make sure you set the Runtime type to T4 GPU if it is not already. Do this by selecting the Change Runtime Type option under the Runtime menu above.

Using a runtime with a GPU will significantly improve the runtime performance for this Colab. As models get more complex, the runtime increases significantly.

Background
For this project, you are going to make an AI that takes an X-ray image as an input and predicts whether the patient has Pneumonia. Your final product will be a prompt to ask the doctor to enter a URL to an image containing a chest X-ray and the output will tell the doctor if the patient is likely to have Pneumonia.

Sample Output for Normal Result:







The X-ray indicated the patient might have Pneumonia.
Setup
The dataset import contains 2 classes, NORMAL and PNEUMONIA. The setup code imports images into a training(train_dir) and validation(validation_dir) directory for you to use. The individual images are in sub-directories from there.

A list called class_names has been created and points to the names of the different categories. The index value for this list will be the same as the output from the model prediction (i.e. 0 corresponds to Normal and 1 corresponds to Pneumonia).

Answer 1

To create an AI that predicts whether a patient has pneumonia based on chest X-ray images in Google Colab, you can follow the steps below. The code involves setting up a convolutional neural network (CNN) to classify the images and then creating an interface for user input via a URL.

Here's the complete code for your project:

```python
# Install required packages
!pip install tensorflow tensorflow-hub pillow

import os
import zipfile
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.preprocessing import image
from tensorflow.keras.models import load_model
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Ensure you have GPU runtime enabled
#!nvidia-smi # Uncomment this if you want to check GPU status

# Set directory for dataset (you can change this as needed)
train_dir = '/content/chest_xray/train'
validation_dir = '/content/chest_xray/val'

# Load dataset URLs
normal_url = 'URL_TO_NORMAL_IMAGES.zip' # Replace with actual URL
pneumonia_url = 'URL_TO_PNEUMONIA_IMAGES.zip' # Replace with actual URL

# Download and extract datasets - Uncomment the lines below to download directly
# !wget {normal_url} -O normal.zip
# !wget {pneumonia_url} -O pneumonia.zip

# Extract the zip files
# with zipfile.ZipFile('normal.zip', 'r') as zip_ref:
# zip_ref.extractall(train_dir + '/NORMAL')

# with zipfile.ZipFile('pneumonia.zip', 'r') as zip_ref:
# zip_ref.extractall(train_dir + '/PNEUMONIA')

# Set up image data generators
train_datagen = ImageDataGenerator(rescale=1.0/255.0)
validation_datagen = ImageDataGenerator(rescale=1.0/255.0)

train_generator = train_datagen.flow_from_directory(
train_dir,
target_size=(150, 150),
batch_size=32,
class_mode='binary'
)

validation_generator = validation_datagen.flow_from_directory(
validation_dir,
target_size=(150, 150),
batch_size=32,
class_mode='binary'
)

# Create a simple CNN model
model = keras.Sequential([
layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Conv2D(128, (3, 3), activation='relu'),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Flatten(),
layers.Dense(128, activation='relu'),
layers.Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model
history = model.fit(
train_generator,
steps_per_epoch=train_generator.samples // 32,
validation_data=validation_generator,
validation_steps=validation_generator.samples // 32,
epochs=10
)

# Save the model
model.save('pneumonia_detection_model.h5')

# Function to load and preprocess image from URL
def load_image(url):
img = image.load_img(url, target_size=(150, 150))
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)
return img_array / 255.0 # Normalize image

# Function for making predictions
def predict_pneumonia(image_url):
img_array = load_image(image_url)
prediction = model.predict(img_array)
return "The X-ray indicated the patient might have Pneumonia." if prediction[0][0] >= 0.5 else "The X-ray indicates the patient is likely Normal."

# User input prompt
image_url = input("Please enter the URL of the chest X-ray image: ")
result = predict_pneumonia(image_url)
print(result)
```

### Instructions on Using the Code:
1. Replace `URL_TO_NORMAL_IMAGES.zip` and `URL_TO_PNEUMONIA_IMAGES.zip` with the actual URLs where your dataset is hosted.
2. Uncomment the sections that download and extract the dataset if you need to load it directly from the web.
3. Run the code in Google Colab, ensuring that you have enabled GPU runtime for faster training.
4. Once the model is trained, you'll be able to input a URL of an X-ray image, and the model will predict whether the patient is likely to have pneumonia.

### Note:
- The model architecture and parameters can be fine-tuned based on your needs.
- Monitor the training using the `history` variable, and you may want to visualize the training history for better insights.
- Depending on the data and model complexity, the number of epochs may be increased for better results.