Python Assignment Experts at phdservices.org will provide you with full support and assistance that are required for a successful completion of your project. Across various domains such as Artificial Intelligence, Machine Learning, and Deep Learning, Python is employed in an extensive manner. By encompassing simple to moderate topics, we list out some interesting projects. To interpret and implement significant theories in these domains, these projects assist students in an efficient manner.
Artificial Intelligence (AI)
Project 1: Tic-Tac-Toe Game with Minimax Algorithm
Goal: A Tic-Tac-Toe game has to be carried out, in which the computer plays in an ideal manner by utilizing the Minimax algorithm.
Missions:
- A Tic-Tac-Toe board must be developed. Then, initiate the game by enabling two players.
- In order to take ideal steps, the Minimax algorithm should be applied for the computer.
- To play in opposition to the computer, we have to combine the Minimax algorithm with the game.
import numpy as np
def print_board(board):
for row in board:
print(” “.join(row))
def check_winner(board):
for row in board:
if row[0] == row[1] == row[2] != ” “:
return row[0]
for col in range(3):
if board[0][col] == board[1][col] == board[2][col] != ” “:
return board[0][col]
if board[0][0] == board[1][1] == board[2][2] != ” “:
return board[0][0]
if board[0][2] == board[1][1] == board[2][0] != ” “:
return board[0][2]
return None
def minimax(board, depth, is_maximizing):
winner = check_winner(board)
if winner == “X”:
return 1
elif winner == “O”:
return -1
elif ” ” not in board.flatten():
return 0
if is_maximizing:
best_score = -np.inf
for i in range(3):
for j in range(3):
if board[i][j] == ” “:
board[i][j] = “X”
score = minimax(board, depth + 1, False)
board[i][j] = ” ”
best_score = max(score, best_score)
return best_score
else:
best_score = np.inf
for i in range(3):
for j in range(3):
if board[i][j] == ” “:
board[i][j] = “O”
score = minimax(board, depth + 1, True)
board[i][j] = ” ”
best_score = min(score, best_score)
return best_score
def best_move(board):
best_score = -np.inf
move = (0, 0)
for i in range(3):
for j in range(3):
if board[i][j] == ” “:
board[i][j] = “X”
score = minimax(board, 0, False)
board[i][j] = ” ”
if score > best_score:
best_score = score
move = (i, j)
return move
def play_game():
board = np.array([[” ” for _ in range(3)] for _ in range(3)])
while True:
print_board(board)
row = int(input(“Enter row (0, 1, 2): “))
col = int(input(“Enter col (0, 1, 2): “))
if board[row][col] == ” “:
board[row][col] = “O”
else:
print(“Invalid move. Try again.”)
continue
if check_winner(board) or ” ” not in board.flatten():
break
move = best_move(board)
board[move] = “X”
if check_winner(board) or ” ” not in board.flatten():
break
print_board(board)
winner = check_winner(board)
if winner:
print(f”{winner} wins!”)
else:
print(“It’s a tie!”)
play_game()
Project 2: A* Search Algorithm
Goal: As a means to identify the shortest route in a grid, the A* search algorithm must be applied.
Missions:
- Including barriers, we need to develop a grid.
- Then, the A* search algorithm has to be employed.
- The route should be visualized, which is detected by the algorithm.
import heapq
def heuristic(a, b):
return abs(a[0] – b[0]) + abs(a[1] – b[1])
def astar_search(grid, start, goal):
neighbors = [(0, 1), (0, -1), (1, 0), (-1, 0)]
close_set = set()
came_from = {}
gscore = {start: 0}
fscore = {start: heuristic(start, goal)}
oheap = []
heapq.heappush(oheap, (fscore[start], start))
while oheap:
current = heapq.heappop(oheap)[1]
if current == goal:
data = []
while current in came_from:
data.append(current)
current = came_from[current]
return data
close_set.add(current)
for i, j in neighbors:
neighbor = current[0] + i, current[1] + j
tentative_g_score = gscore[current] + 1
if 0 <= neighbor[0] < grid.shape[0]:
if 0 <= neighbor[1] < grid.shape[1]:
if grid[neighbor[0]][neighbor[1]] == 1:
continue
else:
continue
else:
continue
if neighbor in close_set and tentative_g_score >= gscore.get(neighbor, 0):
continue
if tentative_g_score < gscore.get(neighbor, 0) or neighbor not in [i[1] for i in oheap]:
came_from[neighbor] = current
gscore[neighbor] = tentative_g_score
fscore[neighbor] = tentative_g_score + heuristic(neighbor, goal)
heapq.heappush(oheap, (fscore[neighbor], neighbor))
return False
grid = np.array([[0, 1, 0, 0, 0, 0],
[0, 1, 0, 1, 1, 0],
[0, 0, 0, 0, 1, 0],
[0, 1, 1, 0, 0, 0],
[0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 0, 0]])
start = (0, 0)
goal = (5, 5)
path = astar_search(grid, start, goal)
if path:
for step in path:
grid[step] = 2
grid[start] = 3
grid[goal] = 4
print(“Path found:”)
print(grid)
else:
print(“No path found”)
Machine Learning (ML)
Project 3: Predicting House Prices with Linear Regression
Goal: In order to forecast house prices, our project utilizes a linear regression model.
Missions:
- Initially, the Boston housing dataset should be imported.
- A linear regression model must be applied and trained.
- Then, we have to assess the functionality of the model.
import numpy as np
import pandas as pd
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# Load the dataset
boston = load_boston()
data = pd.DataFrame(boston.data, columns=boston.feature_names)
data[‘PRICE’] = boston.target
# Split the data
X = data.drop(‘PRICE’, axis=1)
y = data[‘PRICE’]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Train the model
model = LinearRegression()
model.fit(X_train, y_train)
# Predict and evaluate
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f”Mean Squared Error: {mse:.2f}”)
# Print model coefficients
print(“Model Coefficients:”)
print(pd.Series(model.coef_, index=X.columns))
Project 4: Iris Flower Classification with k-NN
Goal: With the aim of categorizing iris flowers, we apply a k-nearest neighbors (k-NN) classifier.
Missions:
- The Iris dataset must be imported.
- Then, a k-NN classifier has to be employed and trained.
- Focus on assessing the functionality of the model.
import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
# Load the dataset
iris = load_iris()
data = pd.DataFrame(iris.data, columns=iris.feature_names)
data[‘species’] = iris.target
# Split the data
X = data.drop(‘species’, axis=1)
y = data[‘species’]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Train the model
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
# Predict and evaluate
y_pred = knn.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f”Accuracy: {accuracy:.2f}”)
# Print classification report
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred, target_names=iris.target_names))
Deep Learning
Project 5: Handwritten Digit Recognition with CNN
Goal: From the MNIST dataset, handwritten digits have to be categorized by utilizing a convolutional neural network (CNN).
Missions:
- To carry out this project, we should import the MNIST dataset.
- A CNN must be applied and trained.
- Then, the model’s functionality has to be assessed.
import numpy as np
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.utils import to_categorical
# Load the dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(-1, 28, 28, 1) / 255.0
X_test = X_test.reshape(-1, 28, 28, 1) / 255.0
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
# Build the model
model = Sequential([
Conv2D(32, (3, 3), activation=’relu’, input_shape=(28, 28, 1)),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation=’relu’),
MaxPooling2D((2, 2)),
Flatten(),
Dense(64, activation=’relu’),
Dense(10, activation=’softmax’)
])
# Compile the model
model.compile(optimizer=’adam’, loss=’categorical_crossentropy’, metrics=[‘accuracy’])
# Train the model
model.fit(X_train, y_train, epochs=5, batch_size=32, validation_split=0.2)
# Evaluate the model
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f”Test Accuracy: {test_acc:.2f}”)
Project 6: Text Sentiment Analysis with RNN
Goal: On text data, the sentiment analysis process has to be carried out through applying a recurrent neural network (RNN).
Missions:
- A text-based sentiment dataset should be imported.
- An RNN must be employed and trained.
- Then, we need to assess the functionality of the model.
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Load the dataset
url = ‘https://raw.githubusercontent.com/laxmimerit/IMDB-Movie-Reviews-LSTM/master/train.tsv’
df = pd.read_csv(url, sep=’\t’)
sentences = df[‘Phrase’].values
labels = df[‘Sentiment’].values
# Tokenize the text
tokenizer = Tokenizer(num_words=10000)
tokenizer.fit_on_texts(sentences)
X = tokenizer.texts_to_sequences(sentences)
X = pad_sequences(X, maxlen=100)
y = pd.get_dummies(labels).values
# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Build the model
model = Sequential([
Embedding(10000, 64, input_length=100),
LSTM(64, return_sequences=True),
LSTM(64),
Dense(5, activation=’softmax’)
])
# Compile the model
model.compile(optimizer=’adam’, loss=’categorical_crossentropy’, metrics=[‘accuracy’])
# Train the model
model.fit(X_train, y_train, epochs=5, batch_size=32, validation_split=0.2)
# Evaluate the model
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test.argmax(axis=1), y_pred.argmax(axis=1))
print(f”Accuracy: {accuracy:.2f}”)
Relevant to different domains such as artificial intelligence, machine learning, and deep learning, we proposed numerous intriguing projects that span from simple to moderate topics. In addition to that, explicit goals and missions are suggested by us, along with an instance of code.
Python assignment assistance is provided by our developers across all domains. If you find yourself in need of clarification, do not hesitate to contact us. Phdservices.org offers Python assignment support not only for students embarking on their programming journey but also for developers in search of additional guidance. Our online Python specialists are available to address your inquiries and assist you in discovering solutions.
