Advance Level Exercises

import pandas as pdfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.linear_model import LogisticRegressionfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # Read the data into a pandas dataframedf = pd.read_csv('data.csv') # Check for missing valuesif df.isnull().sum().sum() > 0:    print("Warning: Missing values detected. Filling with mean values.")    df = df.fillna(df.mean())  # Alternatively, df.dropna() to remove rows with NaN values # Ensure target column existsif 'target' not in df.columns:    raise ValueError("Error: 'target' column not found in dataset.") # Split the data into features and labelsX = df.drop(columns=['target'])y = df['target'] # Split the data into training and testing setsX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y) # Scale the data using standardizationscaler = StandardScaler()X_train_scaled = scaler.fit_transform(X_train)X_test_scaled = scaler.transform(X_test) # Train a logistic regression model with class balancingmodel = LogisticRegression(random_state=42, class_weight='balanced')model.fit(X_train_scaled, y_train) # Make predictions on the test sety_pred = model.predict(X_test_scaled) # Evaluate the model performanceaccuracy = accuracy_score(y_test, y_pred)precision = precision_score(y_test, y_pred, average='weighted')  # Supports multi-classrecall = recall_score(y_test, y_pred, average='weighted')f1 = f1_score(y_test, y_pred, average='weighted') # Print evaluation metricsprint('Accuracy:', round(accuracy, 4))print('Precision:', round(precision, 4))print('Recall:', round(recall, 4))print('F1 score:', round(f1, 4)) 

from flask import Flask, render_template, request app = Flask(__name__) # Define a route for the home page@app.route('/')def home():    return render_template('home.html') # Define a route for the contact page@app.route('/contact', methods=['GET', 'POST'])def contact():    if request.method == 'POST':        name = request.form['name']        email = request.form['email']        message = request.form['message']        # TODO: Process the form data        return 'Thanks for contacting us!'    else:        return render_template('contact.html') if __name__ == '__main__':    app.run(debug=True)

from pykafka import KafkaClientimport json # Kafka broker configurationKAFKA_BROKER = 'localhost:9092'TOPIC_NAME = 'test' try:    # Connect to Kafka broker    client = KafkaClient(hosts=KAFKA_BROKER)     # Get a reference to the topic    topic = client.topics[TOPIC_NAME]     # Create a consumer    consumer = topic.get_simple_consumer()     print(f"Connected to Kafka broker at {KAFKA_BROKER}, consuming messages from topic '{TOPIC_NAME}'...")     # Process messages in real-time    for message in consumer:        if message is not None:            try:                data = json.loads(message.value.decode('utf-8'))  # Decode & parse JSON safely                print("Received message:", data)                 # TODO: Process the data in real-time             except json.JSONDecodeError as e:                print(f"Error decoding JSON: {e} - Raw message: {message.value}") except Exception as e:    print(f"Kafka connection error: {e}") finally:    if 'consumer' in locals():        consumer.stop()  # Ensure consumer is properly stopped        print("Kafka consumer stopped.")

import nltkfrom nltk.tokenize import word_tokenizefrom nltk.stem import PorterStemmerfrom nltk.corpus import stopwords # Download NLTK datanltk.download('punkt')nltk.download('stopwords') # Load the text corpuswith open('corpus.txt', 'r') as f:    corpus = f.read() # Tokenize the corpustokens = word_tokenize(corpus) # Remove stop wordsstop_words = set(stopwords.words('english'))filtered_tokens = [token for token in tokens if token.lower() not in stop_words] # Stem the tokensstemmer = PorterStemmer()stemmed_tokens = [stemmer.stem(token) for token in filtered_tokens] # Print the resultsprint('Original tokens:', tokens[:10])print('Filtered tokens:', filtered_tokens[:10])print('Stemmed tokens:', stemmed_tokens[:10])

import Pyro4 # Define a remote object class@Pyro4.exposeclass MyObject:    def method1(self, arg1):        return f"Processed method1 with argument: {arg1}"     def method2(self, arg2):        return f"Processed method2 with argument: {arg2}" # Start the serverif __name__ == '__main__':    # Locate the name server    ns = Pyro4.locateNS()     # Create a Pyro daemon    daemon = Pyro4.Daemon()     # Register the remote object with the daemon    uri = daemon.register(MyObject)     # Register the object with the name server    ns.register('myobject', uri)     print(f"MyObject is now available. URI: {uri}")     # Run the server loop    daemon.requestLoop() 

import plotly.graph_objs as goimport pandas as pdfrom plotly.subplots import make_subplots  # Correct import # Load the datadf = pd.read_csv('data.csv') # Ensure 'quarter' is a string (for heatmap y-axis)df['quarter'] = df['quarter'].astype(str) # Create tracestrace1 = go.Scatter(x=df['year'], y=df['sales'], mode='lines', name='Sales')trace2 = go.Scatter(x=df['year'], y=df['profit'], mode='markers', name='Profit')trace3 = go.Bar(x=df['year'], y=df['expenses'], name='Expenses')trace4 = go.Heatmap(x=df['year'], y=df['quarter'], z=df['revenue'], colorscale='Viridis', name='Revenue') # Create subplotsfig = make_subplots(rows=2, cols=2, subplot_titles=('Sales', 'Profit', 'Expenses', 'Revenue')) # Add traces correctlyfig.add_trace(trace1, row=1, col=1)fig.add_trace(trace2, row=1, col=2)fig.add_trace(trace3, row=2, col=1)fig.add_trace(trace4, row=2, col=2) # Update layout for better visualizationfig.update_layout(title='Financial Performance', height=800, width=1000) # Display the chartfig.show()

import sqlite3import pandas as pd # Load data from multiple sources into pandas DataFramesdf1 = pd.read_csv('data1.csv')df2 = pd.read_excel('data2.xlsx')df3 = pd.read_json('data3.json') # Standardize column names across datasetsexpected_columns = ['date', 'amount', 'description']  # Adjust based on actual datasetdf1 = df1.reindex(columns=expected_columns, fill_value=None)df2 = df2.reindex(columns=expected_columns, fill_value=None)df3 = df3.reindex(columns=expected_columns, fill_value=None) # Data Cleaning & Transformationdf1['date'] = pd.to_datetime(df1['date'], errors='coerce')  # Handle invalid datesdf2['amount'] = df2['amount'].astype(float) / 100  # Convert to proper currency formatdf3['description'] = df3['description'].astype(str).str.upper()  # Ensure consistency # Merge DataFrames while handling missing valuesdf = pd.concat([df1, df2, df3], axis=0).fillna({'amount': 0, 'description': 'UNKNOWN'}) # Store the data in a SQLite database safelydb_file = 'mydb.db'table_name = 'mytable' with sqlite3.connect(db_file) as conn:    df.to_sql(table_name, conn, if_exists='replace', index=False) print(f"Data successfully saved to SQLite table '{table_name}' in '{db_file}'.")

import nltkimport randomimport os # Download necessary NLTK resourcesnltk.download('punkt') # Define corpus filecorpus_file = 'corpus.txt' # Ensure the corpus file existsif not os.path.exists(corpus_file):    raise FileNotFoundError(f"Error: The file '{corpus_file}' was not found.") # Load the text corpuswith open(corpus_file, 'r', encoding='utf-8') as f:    corpus = f.read() # Tokenize the corpustokens = nltk.word_tokenize(corpus) # Build a dictionary of word transitions (Markov Chain)chain = {}for i in range(len(tokens) - 1):    word1 = tokens[i]    word2 = tokens[i + 1]    if word1 in chain:        chain[word1].append(word2)    else:        chain[word1] = [word2] # Generate text using Markov chainsstart_word = random.choice(list(chain.keys()))sentence = [start_word.capitalize()] while len(sentence) < 100:  # Limit by word count    last_word = sentence[-1].lower()  # Ensure consistent lookup    if last_word in chain:        next_word = random.choice(chain[last_word])        sentence.append(next_word)    else:        break  # Stop if there are no next words # Print the generated textprint(' '.join(sentence)) 

from sklearn import datasetsfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score, classification_report # Load the iris datasetiris = datasets.load_iris() # Split the data into training and testing setsX_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3, random_state=42, stratify=iris.target) # Train a decision tree classifier with hyperparameter tuningclf = DecisionTreeClassifier(max_depth=4, min_samples_split=5, random_state=42)clf.fit(X_train, y_train) # Make predictionsy_pred = clf.predict(X_test) # Evaluate the modelaccuracy = accuracy_score(y_test, y_pred)print('Accuracy:', round(accuracy, 4))print('\nClassification Report:\n', classification_report(y_test, y_pred, target_names=iris.target_names)) # Feature Importance Analysisfeature_importances = dict(zip(iris.feature_names, clf.feature_importances_))print("\nFeature Importances:", feature_importances)

import cv2import os # Load an image safelyimage_path = 'image.jpg'if not os.path.exists(image_path):    raise FileNotFoundError(f"Error: '{image_path}' not found.") img = cv2.imread(image_path) # Convert to grayscalegray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Apply median filterfiltered = cv2.medianBlur(gray, 5) # Apply adaptive thresholdingthresh = cv2.adaptiveThreshold(filtered, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2) # Apply morphological operationskernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel) # Find contourscontours_info = cv2.findContours(closed, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)contours = contours_info[0] if len(contours_info) == 2 else contours_info[1]  # Safe unpacking # Draw contours on the original imagecv2.drawContours(img, contours, -1, (0, 0, 255), 2) # Save and display the processed imagescv2.imwrite('output_contours.jpg', img)cv2.imwrite('output_thresholded.jpg', thresh)cv2.imwrite('output_closed.jpg', closed) print("Processing complete. Images saved as 'output_contours.jpg', 'output_thresholded.jpg', and 'output_closed.jpg'.") # Display the images (comment out if running on a headless system)cv2.imshow('Original', img)cv2.imshow('Thresholded', thresh)cv2.imshow('Closed', closed)cv2.waitKey(0)cv2.destroyAllWindows()

import socket # Create a socket objects = socket.socket() # Define the server address and port numberhost = 'localhost'port = 12345 # Connect to the servers.connect((host, port)) # Send data to the servers.send(b'Hello, server!') # Receive data from the serverdata = s.recv(1024) # Close the sockets.close() # Print the received dataprint('Received:', data.decode())

from flask import Flask # Create a Flask applicationapp = Flask(__name__) # Define a route@app.route('/')def hello():    return 'Hello, world!' # Run the application (for development only)if __name__ == '__main__':    app.run(host='0.0.0.0', port=5000, debug=True)  # Set debug=True only for development

import spacy # Ensure the model is installed before running the script:# Run: python -m spacy download en_core_web_sm # Load the English language modeltry:    nlp = spacy.load('en_core_web_sm')except OSError:    raise OSError("Spacy model 'en_core_web_sm' not found. Run 'python -m spacy download en_core_web_sm' and try again.") # Define some text to processtext = 'Barack Obama was born in Hawaii.' # Process the textdoc = nlp(text) # Extract named entities from the textentities = [(ent.text, ent.label_) for ent in doc.ents] # Display resultsif entities:    print("\nNamed Entities Found:")    for text, label in entities:        print(f" - {text}: {label}")else:    print("\nNo named entities found in the text.")

import tensorflow as tffrom tensorflow.keras import datasets, layers, modelsfrom tensorflow.keras.preprocessing.image import ImageDataGeneratorfrom tensorflow.keras.callbacks import EarlyStopping # Load the CIFAR-10 dataset(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data() # Normalize the pixel valuestrain_images, test_images = train_images / 255.0, test_images / 255.0 # Data Augmentation to prevent overfittingdatagen = ImageDataGenerator(    rotation_range=15,    width_shift_range=0.1,    height_shift_range=0.1,    horizontal_flip=True) # Define the model architecturemodel = models.Sequential([    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),    layers.MaxPooling2D((2, 2)),     layers.Conv2D(64, (3, 3), activation='relu'),    layers.MaxPooling2D((2, 2)),     layers.Conv2D(128, (3, 3), activation='relu'),    layers.MaxPooling2D((2, 2)),     layers.Flatten(),    layers.Dense(128, activation='relu'),    layers.Dropout(0.5),  # Prevent overfitting    layers.Dense(10, activation='softmax')  # Use Softmax for probabilities]) # Compile the modelmodel.compile(optimizer='adam',              loss=tf.keras.losses.SparseCategoricalCrossentropy(),              metrics=['accuracy']) # Define early stopping to stop training if no improvementearly_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True) # Train the model with data augmentationmodel.fit(datagen.flow(train_images, train_labels, batch_size=64),          validation_data=(test_images, test_labels),          epochs=30, callbacks=[early_stopping]) # Evaluate the modeltest_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)print('Test accuracy:', round(test_acc * 100, 2), '%')

import pandas as pdimport matplotlib.pyplot as plt # Load the datadf = pd.read_csv('data.csv') # Convert 'date' column to datetime formatdf['date'] = pd.to_datetime(df['date'], errors='coerce') # Drop rows with missing or invalid datesdf.dropna(subset=['date'], inplace=True) # Convert 'price' and 'quantity' to numeric values (if not already)df['price'] = pd.to_numeric(df['price'], errors='coerce')df['quantity'] = pd.to_numeric(df['quantity'], errors='coerce') # Drop rows with missing or invalid price/quantitydf.dropna(subset=['price', 'quantity'], inplace=True) # Compute total salesdf['total_sales'] = df['price'] * df['quantity'] # Set date as index for proper resamplingdf.set_index('date', inplace=True) # Group by month and sum salesmonthly_sales = df.resample('M').sum() # Visualize the dataplt.figure(figsize=(10, 5))plt.plot(monthly_sales.index, monthly_sales['total_sales'], marker='o', linestyle='-')plt.xlabel('Month')plt.ylabel('Total Sales')plt.title('Monthly Sales Trend')plt.grid()plt.xticks(rotation=45)plt.show()

import numpy as npimport pandas as pdimport matplotlib.pyplot as plt # Load the datadf = pd.read_csv('data.csv') # Convert 'date' column to datetime formatdf['date'] = pd.to_datetime(df['date'], errors='coerce') # Drop rows with missing or invalid datesdf.dropna(subset=['date'], inplace=True) # Convert 'price' and 'quantity' to numeric values (if not already)df['price'] = pd.to_numeric(df['price'], errors='coerce')df['quantity'] = pd.to_numeric(df['quantity'], errors='coerce') # Drop rows with missing or invalid price/quantitydf.dropna(subset=['price', 'quantity'], inplace=True) # Compute total salesdf['total_sales'] = df['price'] * df['quantity'] # Set date as index for proper resamplingdf.set_index('date', inplace=True) # Group by month and sum salesmonthly_sales = df.resample('M').sum() # Analyze the dataprint('Total Sales:', round(df['total_sales'].sum(), 2))print('Average Price:', round(df['price'].mean(), 2))print('Median Quantity:', df['quantity'].median()) # Visualize the dataplt.figure(figsize=(10, 5))plt.plot(monthly_sales.index, monthly_sales['total_sales'], marker='o', linestyle='-', color='b', label='Total Sales')plt.xlabel('Month')plt.ylabel('Total Sales')plt.title('Monthly Sales Trend')plt.legend()plt.grid()plt.xticks(rotation=45)plt.show()

import numpy as npfrom sklearn import datasets, svmfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.metrics import accuracy_score, classification_report, confusion_matrix # Load the iris datasetiris = datasets.load_iris() # Split the data into training and testing setsX_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42, stratify=iris.target) # Standardize the data (SVMs perform better with scaled data)scaler = StandardScaler()X_train_scaled = scaler.fit_transform(X_train)X_test_scaled = scaler.transform(X_test) # Train a Support Vector Machine classifierclf = svm.SVC(kernel='linear', C=1.0, random_state=42)clf.fit(X_train_scaled, y_train) # Predict the labelsy_pred = clf.predict(X_test_scaled) # Evaluate the classifieraccuracy = accuracy_score(y_test, y_pred)print(f'Accuracy: {accuracy:.4f}\n') # Print detailed evaluation metricsprint("Classification Report:\n", classification_report(y_test, y_pred, target_names=iris.target_names))print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))

import requestsfrom bs4 import BeautifulSoup # Define the target URLurl = 'https://en.wikipedia.org/wiki/Python_(programming_language)' # Add headers to prevent request blockingheaders = {'User-Agent': 'Mozilla/5.0'} # Fetch the HTML content of the websiteresponse = requests.get(url, headers=headers) # Check if the request was successfulif response.status_code != 200:    print(f"Error: Unable to fetch the page (Status Code: {response.status_code})")    exit() # Parse the HTML content using BeautifulSoupsoup = BeautifulSoup(response.text, 'html.parser') # Extract the page titletitle = soup.title.stringprint(f"\nPage Title: {title}\n") # Extract all valid linksbase_url = 'https://en.wikipedia.org'links = [] for link in soup.find_all('a', href=True):  # Ensures 'href' exists    href = link.get('href')     # Convert relative Wikipedia links to absolute URLs    if href.startswith('/wiki/'):        full_url = base_url + href        links.append(full_url)    elif href.startswith('http'):  # Keep only valid external links        links.append(href) # Print the first 10 links for brevityprint("Extracted Links:")for l in links[:10]:  # Limit output for readability    print(l) print(f"\nTotal Links Found: {len(links)}")

import sqlite3 # Connect to the database using a context managerwith sqlite3.connect('data.db') as conn:    cursor = conn.cursor()     # Create a table (if it doesn't exist)    cursor.execute('''CREATE TABLE IF NOT EXISTS users (                      id INTEGER PRIMARY KEY AUTOINCREMENT,                      name TEXT NOT NULL,                      age INTEGER NOT NULL);''')     # Insert data into the table (use parameterized queries)    cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('John Doe', 30))    cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Jane Doe', 25))     # Retrieve data from the table    cursor.execute('SELECT * FROM users')    users = cursor.fetchall()  # Fetch all rows     print("\nUsers in database:")    for user in users:        print(user)     # Update data using a parameterized query    cursor.execute("UPDATE users SET age = ? WHERE name = ?", (35, 'John Doe'))     # Delete data using a parameterized query    cursor.execute("DELETE FROM users WHERE name = ?", ('Jane Doe',))     # Commit the changes (happens automatically with `with` statement)    conn.commit() print("\nDatabase operations completed successfully.")

from flask import Flaskimport boto3import os # Create a Flask applicationapp = Flask(__name__) # AWS S3 ConfigurationAWS_BUCKET_NAME = 'my-bucket'AWS_REGION = 'us-east-1'  # Change to your region # Upload function for AWS S3def upload_to_s3(file_name, bucket_name, object_name=None):    """Uploads a file to S3"""    try:        s3 = boto3.client('s3')  # Ensure credentials are configured        object_name = object_name or file_name  # Default object name         # Upload file        s3.upload_file(file_name, bucket_name, object_name)        print(f"File '{file_name}' uploaded successfully to S3 bucket '{bucket_name}'.")     except Exception as e:        print(f"Error uploading to S3: {e}") # Define a route@app.route('/')def hello():    return 'Hello, world! Flask is running!' # Run the applicationif __name__ == '__main__':    # Upload a file to S3 before starting Flask (Optional)    if os.path.exists('app.py'):        upload_to_s3('app.py', AWS_BUCKET_NAME)     # Run Flask server    app.run(host='0.0.0.0', port=5000, debug=True)

import nltk # Download required NLTK modelsnltk.download('punkt')nltk.download('maxent_ne_chunker')nltk.download('words')nltk.download('averaged_perceptron_tagger') # Load the text datatext = '''Apple Inc. is an American multinational technology company headquartered in Cupertino, California, that designs, develops, and sells consumer electronics, computer software, and online services. The company's hardware products include the iPhone smartphone, the iPad tablet computer, the Mac personal computer, the iPod portable media player, the Apple Watch smartwatch, the Apple TV digital media player, and the HomePod smart speaker. Apple's software includes the macOS and iOS operating systems, the iTunes media player, the Safari web browser, and the iLife and iWork creativity and productivity suites. Its online services include the iTunes Store, the iOS App Store, and Mac App Store, Apple Music, and iCloud.''' # Tokenize the texttokens = nltk.word_tokenize(text) # Perform part-of-speech taggingpos_tags = nltk.pos_tag(tokens) # Perform named entity recognitionne_tags = nltk.ne_chunk(pos_tags) # Extract named entitiesnamed_entities = {} for chunk in ne_tags:    if hasattr(chunk, 'label'):        entity_type = chunk.label()  # Get entity type (e.g., ORGANIZATION, PERSON)        entity_name = ' '.join(c[0] for c in chunk)  # Join words in entity         if entity_type not in named_entities:            named_entities[entity_type] = []        named_entities[entity_type].append(entity_name) # Print structured named entitiesprint("\nNamed Entities Found:")for entity_type, names in named_entities.items():    print(f"{entity_type}: {', '.join(set(names))}")  # Use `set()` to remove duplicates

from pyspark.sql import SparkSessionimport re # Initialize Spark sessionspark = SparkSession.builder.appName('WordCount').getOrCreate()sc = spark.sparkContext # Load the text datatext = sc.textFile('data.txt') # Process and count wordsword_counts = (    text.flatMap(lambda line: line.split())  # Split on any whitespace    .map(lambda word: re.sub(r'\W+', '', word.lower()))  # Remove punctuation & normalize to lowercase    .filter(lambda word: word)  # Remove empty strings    .map(lambda word: (word, 1))  # Convert words into (word, 1) pairs    .reduceByKey(lambda a, b: a + b)  # Sum occurrences of each word) # Collect and print resultsfor word, count in word_counts.collect():    print(word, count) # Stop Spark sessionsc.stop()

from scapy.all import sniff, TCP, conf # Ensure non-root users can run it in a limited wayconf.sniff_promisc = False # Define a packet handler functiondef packet_handler(packet):    if packet.haslayer(TCP) and packet[TCP].flags & 2:  # Check for SYN flag        print('SYN packet detected:', packet.summary()) # Start the packet sniffer with exception handlingtry:    print("Sniffing TCP packets (Press Ctrl+C to stop)...")    sniff(prn=packet_handler, filter='tcp', store=0, count=100)  # Capture only 100 packetsexcept KeyboardInterrupt:    print("\nPacket sniffing stopped by user.")

from sklearn import datasetsfrom sklearn.model_selection import GridSearchCV, StratifiedKFoldfrom sklearn.preprocessing import StandardScalerfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.pipeline import Pipeline # Load the datasetiris = datasets.load_iris()X, y = iris.data, iris.target # Define the hyperparameter gridparam_grid = {    'knn__n_neighbors': [1, 3, 5, 7, 9, 11, 15],    'knn__weights': ['uniform', 'distance']} # Create a pipeline with feature scaling and KNNpipeline = Pipeline([    ('scaler', StandardScaler()),    ('knn', KNeighborsClassifier())]) # Perform a grid search with stratified cross-validationcv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)grid_search = GridSearchCV(pipeline, param_grid, cv=cv, n_jobs=-1, scoring='accuracy')grid_search.fit(X, y) # Print best hyperparameters and accuracy scoreprint('Best Hyperparameters:', grid_search.best_params_)print(f'Best Accuracy Score: {grid_search.best_score_:.4f}')

import cv2import os # Define pathsimage_path = 'image.jpg'cascade_path = 'haarcascade_frontalface_default.xml' # Ensure the image file existsif not os.path.exists(image_path):    raise FileNotFoundError(f"Error: Image file '{image_path}' not found.") # Load the imageimg = cv2.imread(image_path) # Convert the image to grayscalegray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Load the face detection cascade classifierface_cascade = cv2.CascadeClassifier(cascade_path) # Ensure the cascade file is loaded properlyif face_cascade.empty():    raise FileNotFoundError(f"Error: Haar Cascade XML file '{cascade_path}' not found or failed to load.") # Detect faces in the imagefaces = face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5, minSize=(30, 30)) # Draw rectangles around detected facesfor (x, y, w, h) in faces:    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2) # Display the image with detected facescv2.imshow('Detected Faces', img) # Ensure proper cleanuptry:    cv2.waitKey(0)    cv2.destroyAllWindows()except Exception as e:    print("Error while closing windows:", e)