Upload 4 files

house_price_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8acc22df8f21e40119fee45e08cb8575ee66d063c8768ad2cea77197a74868e
+size 76800

house_price_prediction.py

@@ -0,0 +1,221 @@
+# Assignment 1: House Price Prediction using Deep Learning
+# This program predicts house prices based on various features like size, bedrooms, location, etc.
+
+# Step 1: Import all necessary libraries
+import numpy as np  # For numerical calculations
+import pandas as pd  # For handling data in table format
+import matplotlib.pyplot as plt  # For creating graphs
+import seaborn as sns  # For better looking graphs
+from sklearn.model_selection import train_test_split  # To split data for training and testing
+from sklearn.preprocessing import StandardScaler  # To normalize our data
+from sklearn.datasets import fetch_california_housing  # Built-in housing dataset
+from tensorflow import keras  # Deep learning library
+from tensorflow.keras import layers  # To build neural network layers
+import warnings
+warnings.filterwarnings('ignore')  # Hide unnecessary warnings
+
+# Step 2: Load the California Housing Dataset
+# This is a famous dataset that's built into sklearn - no need to download separately!
+print("Loading the California Housing Dataset...")
+housing = fetch_california_housing()  # Get the dataset
+X = housing.data  # Features (things we know about houses)
+y = housing.target  # Target (actual prices we want to predict)
+
+# Convert to pandas DataFrame for easier handling
+feature_names = housing.feature_names
+df = pd.DataFrame(X, columns=feature_names)
+df['Price'] = y
+
+# Step 3: Explore the data
+print("\n=== Dataset Information ===")
+print(f"Total number of houses: {len(df)}")
+print(f"Number of features: {len(feature_names)}")
+print("\nFeatures in our dataset:")
+for i, feature in enumerate(feature_names, 1):
+    print(f"{i}. {feature}")
+
+print("\n=== First 5 houses in our dataset ===")
+print(df.head())
+
+print("\n=== Basic Statistics ===")
+print(df.describe())
+
+# Step 4: Create visualizations to understand our data
+print("\n Creating visualizations...")
+
+# Create a figure with multiple plots
+fig, axes = plt.subplots(2, 2, figsize=(12, 10))
+
+# Plot 1: Distribution of house prices
+axes[0, 0].hist(df['Price'], bins=50, color='blue', alpha=0.7)
+axes[0, 0].set_title('Distribution of House Prices')
+axes[0, 0].set_xlabel('Price (in hundreds of thousands)')
+axes[0, 0].set_ylabel('Number of Houses')
+
+# Plot 2: Relationship between house age and price
+axes[0, 1].scatter(df['HouseAge'], df['Price'], alpha=0.5, color='green')
+axes[0, 1].set_title('House Age vs Price')
+axes[0, 1].set_xlabel('House Age (years)')
+axes[0, 1].set_ylabel('Price')
+
+# Plot 3: Relationship between rooms and price
+axes[1, 0].scatter(df['AveRooms'], df['Price'], alpha=0.5, color='red')
+axes[1, 0].set_title('Average Rooms vs Price')
+axes[1, 0].set_xlabel('Average Rooms')
+axes[1, 0].set_ylabel('Price')
+
+# Plot 4: Relationship between income and price
+axes[1, 1].scatter(df['MedInc'], df['Price'], alpha=0.5, color='purple')
+axes[1, 1].set_title('Median Income vs Price')
+axes[1, 1].set_xlabel('Median Income')
+axes[1, 1].set_ylabel('Price')
+
+plt.tight_layout()
+plt.savefig('house_data_exploration.png')
+plt.show()
+
+# Step 5: Prepare data for the deep learning model
+print("\n=== Preparing Data for Model ===")
+
+# Split features (X) and target (y)
+X = df.drop('Price', axis=1).values  # Everything except price
+y = df['Price'].values  # Just the prices
+
+# Split into training set (80%) and testing set (20%)
+# Training set: Used to teach the model
+# Testing set: Used to check how well the model learned
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+print(f"Training set size: {len(X_train)} houses")
+print(f"Testing set size: {len(X_test)} houses")
+
+# Step 6: Normalize the data
+# This makes all features have similar scales (important for neural networks)
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)  # Learn the scaling from training data
+X_test_scaled = scaler.transform(X_test)  # Apply same scaling to test data
+
+# Step 7: Build the Deep Learning Model
+print("\n=== Building Deep Learning Model ===")
+
+# Create a Sequential model (layers stacked one after another)
+model = keras.Sequential([
+    # Input layer - takes our 8 features
+    layers.Dense(64, activation='relu', input_shape=[8]),
+    # Hidden layer 1 - 64 neurons (brain cells)
+    layers.Dropout(0.2),  # Prevents overfitting by randomly turning off neurons
+    
+    # Hidden layer 2 - 32 neurons
+    layers.Dense(32, activation='relu'),
+    layers.Dropout(0.2),
+    
+    # Hidden layer 3 - 16 neurons
+    layers.Dense(16, activation='relu'),
+    
+    # Output layer - 1 neuron for the predicted price
+    layers.Dense(1)
+])
+
+# Step 8: Compile the model
+# This tells the model how to learn
+model.compile(
+    optimizer='adam',  # Algorithm for learning (Adam is very popular)
+    loss='mse',  # Mean Squared Error - measures how wrong our predictions are
+    metrics=['mae']  # Mean Absolute Error - average difference from actual price
+)
+
+# Print model architecture
+print("\nModel Architecture:")
+model.summary()
+
+# Step 9: Train the model
+print("\n=== Training the Model ===")
+print("This may take 1-2 minutes...")
+
+# Train the model
+history = model.fit(
+    X_train_scaled,  # Training features
+    y_train,  # Training prices
+    epochs=100,  # Number of times to go through all data
+    batch_size=32,  # Number of samples to process at once
+    validation_split=0.2,  # Use 20% of training data for validation
+    verbose=0  # Don't print progress for each epoch
+)
+
+print("Training completed!")
+
+# Step 10: Visualize the training process
+print("\n Creating training visualizations...")
+
+fig, axes = plt.subplots(1, 2, figsize=(12, 4))
+
+# Plot training & validation loss
+axes[0].plot(history.history['loss'], label='Training Loss')
+axes[0].plot(history.history['val_loss'], label='Validation Loss')
+axes[0].set_title('Model Loss During Training')
+axes[0].set_xlabel('Epoch')
+axes[0].set_ylabel('Loss (MSE)')
+axes[0].legend()
+
+# Plot training & validation MAE
+axes[1].plot(history.history['mae'], label='Training MAE')
+axes[1].plot(history.history['val_mae'], label='Validation MAE')
+axes[1].set_title('Model MAE During Training')
+axes[1].set_xlabel('Epoch')
+axes[1].set_ylabel('Mean Absolute Error')
+axes[1].legend()
+
+plt.tight_layout()
+plt.savefig('training_history.png')
+plt.show()
+
+# Step 11: Evaluate the model on test data
+print("\n=== Model Evaluation ===")
+test_loss, test_mae = model.evaluate(X_test_scaled, y_test, verbose=0)
+print(f"Test Loss (MSE): {test_loss:.4f}")
+print(f"Test MAE: {test_mae:.4f}")
+print(f"This means our predictions are off by ${test_mae*100000:.2f} on average")
+
+# Step 12: Make predictions and visualize results
+print("\n=== Making Predictions ===")
+predictions = model.predict(X_test_scaled, verbose=0)
+
+# Plot actual vs predicted prices
+plt.figure(figsize=(10, 6))
+plt.scatter(y_test, predictions, alpha=0.5)
+plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
+plt.xlabel('Actual Price')
+plt.ylabel('Predicted Price')
+plt.title('Actual vs Predicted House Prices')
+plt.savefig('predictions.png')
+plt.show()
+
+# Step 13: Show some example predictions
+print("\n=== Sample Predictions ===")
+print("Comparing actual prices with our model's predictions:\n")
+for i in range(5):
+    actual = y_test[i] * 100000
+    predicted = predictions[i][0] * 100000
+    difference = abs(actual - predicted)
+    print(f"House {i+1}:")
+    print(f"  Actual Price: ${actual:,.2f}")
+    print(f"  Predicted Price: ${predicted:,.2f}")
+    print(f"  Difference: ${difference:,.2f}")
+    print()
+
+# Step 14: Save the model
+print("=== Saving the Model ===")
+model.save('house_price_model.h5')
+print("Model saved as 'house_price_model.h5'")
+
+# Step 15: Calculate accuracy metrics
+from sklearn.metrics import r2_score
+r2 = r2_score(y_test, predictions)
+print(f"\n=== Final Model Performance ===")
+print(f"R² Score: {r2:.4f}")
+print(f"This means our model explains {r2*100:.2f}% of the price variations")
+
+print("\n✅ Assignment 1 Complete! Your deep learning model is ready!")
+print("Files created: house_price_model.h5, house_data_exploration.png, training_history.png, predictions.png")

image_classification.py

@@ -0,0 +1,290 @@
+# Assignment 2: Image Classification using Deep Learning (Computer Vision)
+# This program classifies images into different categories using a Convolutional Neural Network (CNN)
+
+# Step 1: Import all necessary libraries
+import numpy as np  # For numerical calculations
+import matplotlib.pyplot as plt  # For showing images and graphs
+import tensorflow as tf  # Main deep learning library
+from tensorflow import keras  # High-level API for building models
+from tensorflow.keras import layers  # For creating neural network layers
+from tensorflow.keras.datasets import cifar10  # Built-in image dataset
+from tensorflow.keras.utils import to_categorical  # For preparing labels
+import warnings
+warnings.filterwarnings('ignore')  # Hide unnecessary warnings
+
+# Step 2: Load the CIFAR-10 Dataset
+# CIFAR-10 is a famous dataset with 60,000 small color images in 10 classes
+print("=== Loading CIFAR-10 Dataset ===")
+print("This dataset contains 60,000 32x32 color images in 10 categories")
+print("Downloading dataset (this may take a minute on first run)...\n")
+
+# Load the data - it's automatically split into training and testing sets
+(X_train, y_train), (X_test, y_test) = cifar10.load_data()
+
+# Define the 10 classes in CIFAR-10
+class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
+               'dog', 'frog', 'horse', 'ship', 'truck']
+
+# Step 3: Explore the dataset
+print("=== Dataset Information ===")
+print(f"Training images: {X_train.shape[0]}")
+print(f"Testing images: {X_test.shape[0]}")
+print(f"Image shape: {X_train.shape[1:]} (32x32 pixels, 3 color channels for RGB)")
+print(f"Number of classes: {len(class_names)}")
+print(f"Classes: {', '.join(class_names)}\n")
+
+# Step 4: Visualize sample images from the dataset
+print("=== Visualizing Sample Images ===")
+fig, axes = plt.subplots(3, 5, figsize=(12, 8))
+fig.suptitle('Sample Images from CIFAR-10 Dataset', fontsize=16)
+
+for i in range(15):
+    # Select random image
+    idx = np.random.randint(0, len(X_train))
+    image = X_train[idx]
+    label = class_names[y_train[idx][0]]
+    
+    # Plot the image
+    ax = axes[i // 5, i % 5]
+    ax.imshow(image)
+    ax.set_title(f'Class: {label}')
+    ax.axis('off')
+
+plt.tight_layout()
+plt.savefig('sample_images.png')
+plt.show()
+
+# Step 5: Preprocess the data
+print("\n=== Preprocessing Data ===")
+
+# Normalize pixel values to be between 0 and 1 (instead of 0-255)
+# This helps the neural network learn better
+X_train = X_train.astype('float32') / 255.0
+X_test = X_test.astype('float32') / 255.0
+print("✓ Normalized pixel values to range [0, 1]")
+
+# Convert labels to categorical (one-hot encoding)
+# Example: label 3 becomes [0,0,0,1,0,0,0,0,0,0]
+y_train_categorical = to_categorical(y_train, 10)
+y_test_categorical = to_categorical(y_test, 10)
+print("✓ Converted labels to categorical format")
+
+# Step 6: Build the Convolutional Neural Network (CNN)
+print("\n=== Building CNN Model ===")
+print("Creating a Convolutional Neural Network for image classification...")
+
+# Create the model
+model = keras.Sequential([
+    # First Convolutional Block
+    # Conv2D layer: Detects features like edges and shapes
+    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
+    layers.BatchNormalization(),  # Normalizes the outputs to improve training
+    layers.Conv2D(32, (3, 3), activation='relu'),
+    layers.BatchNormalization(),
+    layers.MaxPooling2D((2, 2)),  # Reduces image size while keeping important features
+    layers.Dropout(0.25),  # Prevents overfitting
+    
+    # Second Convolutional Block
+    # These layers detect more complex features
+    layers.Conv2D(64, (3, 3), activation='relu'),
+    layers.BatchNormalization(),
+    layers.Conv2D(64, (3, 3), activation='relu'),
+    layers.BatchNormalization(),
+    layers.MaxPooling2D((2, 2)),
+    layers.Dropout(0.25),
+    
+    # Third Convolutional Block
+    # These layers detect even more complex patterns
+    layers.Conv2D(128, (3, 3), activation='relu'),
+    layers.BatchNormalization(),
+    layers.MaxPooling2D((2, 2)),
+    layers.Dropout(0.25),
+    
+    # Flatten and Dense Layers
+    layers.Flatten(),  # Convert 2D features to 1D for classification
+    layers.Dense(128, activation='relu'),  # Fully connected layer
+    layers.BatchNormalization(),
+    layers.Dropout(0.5),
+    layers.Dense(10, activation='softmax')  # Output layer with 10 classes
+])
+
+# Step 7: Compile the model
+print("\nCompiling the model...")
+model.compile(
+    optimizer='adam',  # Optimization algorithm
+    loss='categorical_crossentropy',  # Loss function for multi-class classification
+    metrics=['accuracy']  # Track accuracy during training
+)
+
+# Display model architecture
+print("\nModel Architecture:")
+model.summary()
+print(f"\nTotal parameters: {model.count_params():,}")
+
+# Step 8: Set up data augmentation (optional but improves accuracy)
+print("\n=== Setting up Data Augmentation ===")
+print("Data augmentation creates variations of images to improve model generalization")
+
+# Create data augmentation layer
+data_augmentation = keras.Sequential([
+    layers.RandomFlip("horizontal"),  # Randomly flip images horizontally
+    layers.RandomRotation(0.1),  # Randomly rotate images
+    layers.RandomZoom(0.1),  # Randomly zoom images
+])
+
+# Step 9: Train the model
+print("\n=== Training the Model ===")
+print("This will take 3-5 minutes depending on your computer...")
+print("The model will learn to recognize patterns in the images\n")
+
+# Use callbacks for better training
+early_stopping = keras.callbacks.EarlyStopping(
+    monitor='val_loss',
+    patience=10,
+    restore_best_weights=True
+)
+
+reduce_lr = keras.callbacks.ReduceLROnPlateau(
+    monitor='val_loss',
+    factor=0.5,
+    patience=5,
+    min_lr=0.00001
+)
+
+# Train the model
+history = model.fit(
+    X_train, y_train_categorical,
+    batch_size=64,  # Number of images to process at once
+    epochs=30,  # Number of times to go through the entire dataset
+    validation_data=(X_test, y_test_categorical),  # Test data for validation
+    callbacks=[early_stopping, reduce_lr],  # Training helpers
+    verbose=1  # Show progress bar
+)
+
+print("\n✓ Training completed!")
+
+# Step 10: Visualize training history
+print("\n=== Visualizing Training History ===")
+
+fig, axes = plt.subplots(1, 2, figsize=(12, 4))
+
+# Plot accuracy
+axes[0].plot(history.history['accuracy'], label='Training Accuracy')
+axes[0].plot(history.history['val_accuracy'], label='Validation Accuracy')
+axes[0].set_title('Model Accuracy')
+axes[0].set_xlabel('Epoch')
+axes[0].set_ylabel('Accuracy')
+axes[0].legend()
+axes[0].grid(True)
+
+# Plot loss
+axes[1].plot(history.history['loss'], label='Training Loss')
+axes[1].plot(history.history['val_loss'], label='Validation Loss')
+axes[1].set_title('Model Loss')
+axes[1].set_xlabel('Epoch')
+axes[1].set_ylabel('Loss')
+axes[1].legend()
+axes[1].grid(True)
+
+plt.tight_layout()
+plt.savefig('training_history_cv.png')
+plt.show()
+
+# Step 11: Evaluate the model
+print("\n=== Model Evaluation ===")
+test_loss, test_accuracy = model.evaluate(X_test, y_test_categorical, verbose=0)
+print(f"Test Accuracy: {test_accuracy*100:.2f}%")
+print(f"Test Loss: {test_loss:.4f}")
+
+# Step 12: Make predictions and show results
+print("\n=== Making Predictions on Test Images ===")
+
+# Get predictions for test set
+predictions = model.predict(X_test[:20], verbose=0)
+
+# Visualize predictions
+fig, axes = plt.subplots(4, 5, figsize=(15, 12))
+fig.suptitle('Model Predictions on Test Images', fontsize=16)
+
+for i in range(20):
+    # Get image and predictions
+    image = X_test[i]
+    true_label = class_names[y_test[i][0]]
+    predicted_label = class_names[np.argmax(predictions[i])]
+    confidence = np.max(predictions[i]) * 100
+    
+    # Plot image
+    ax = axes[i // 5, i % 5]
+    ax.imshow(image)
+    
+    # Color code: green for correct, red for incorrect
+    color = 'green' if true_label == predicted_label else 'red'
+    ax.set_title(f'True: {true_label}\nPred: {predicted_label}\nConf: {confidence:.1f}%', 
+                 color=color, fontsize=10)
+    ax.axis('off')
+
+plt.tight_layout()
+plt.savefig('predictions_cv.png')
+plt.show()
+
+# Step 13: Create confusion matrix
+print("\n=== Creating Confusion Matrix ===")
+from sklearn.metrics import confusion_matrix, classification_report
+import seaborn as sns
+
+# Get predictions for entire test set
+y_pred = model.predict(X_test, verbose=0)
+y_pred_classes = np.argmax(y_pred, axis=1)
+y_true_classes = y_test.reshape(-1)
+
+# Create confusion matrix
+cm = confusion_matrix(y_true_classes, y_pred_classes)
+
+# Plot confusion matrix
+plt.figure(figsize=(10, 8))
+sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+            xticklabels=class_names, yticklabels=class_names)
+plt.title('Confusion Matrix')
+plt.xlabel('Predicted Label')
+plt.ylabel('True Label')
+plt.savefig('confusion_matrix.png')
+plt.show()
+
+# Step 14: Print classification report
+print("\n=== Classification Report ===")
+print(classification_report(y_true_classes, y_pred_classes, target_names=class_names))
+
+# Step 15: Save the model
+print("\n=== Saving the Model ===")
+model.save('image_classifier_model.h5')
+print("Model saved as 'image_classifier_model.h5'")
+
+# Step 16: Test with a single image
+print("\n=== Testing with a Single Image ===")
+
+# Pick a random test image
+test_idx = np.random.randint(0, len(X_test))
+test_image = X_test[test_idx]
+test_label = class_names[y_test[test_idx][0]]
+
+# Make prediction
+single_prediction = model.predict(test_image.reshape(1, 32, 32, 3), verbose=0)
+predicted_class = class_names[np.argmax(single_prediction)]
+confidence = np.max(single_prediction) * 100
+
+# Display the image and prediction
+plt.figure(figsize=(6, 6))
+plt.imshow(test_image)
+plt.title(f'Actual: {test_label}\nPredicted: {predicted_class}\nConfidence: {confidence:.2f}%')
+plt.axis('off')
+plt.savefig('single_prediction.png')
+plt.show()
+
+print(f"Actual class: {test_label}")
+print(f"Predicted class: {predicted_class}")
+print(f"Confidence: {confidence:.2f}%")
+
+print("\n✅ Assignment 2 Complete! Your computer vision model is ready!")
+print("Files created: image_classifier_model.h5, sample_images.png, training_history_cv.png,")
+print("              predictions_cv.png, confusion_matrix.png, single_prediction.png")
+print("\nYour model can now classify images into 10 different categories!")

image_classifier_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37bd8b9196513b614e1b5d632b9c880b4b81d411d76a426e452553313b02f193
+size 2017456