This project presents and analyzes recent research on Music Emotion Recognition (MER) with an emphasis on Deep Learning–based approaches. The presentation synthesizes findings from two representative and well-cited studies in the field, focusing on how neural network models are used to identify and classify emotional content in music signals.

Objectives

The objective of this project is to explain the core problem of music emotion recognition and why it remains a challenging task in affective computing.

Results

The presentation was completed and delivered, clearly outlining the MER problem, common modeling strategies, and current research directions. Through conceptual diagrams and structured analysis, the project demonstrated how Deep Learning enables more accurate and scalable emotion classification compared to traditional Machine Learning approaches. The analysis provided a coherent understanding of how MER research has evolved and where future work is needed, particularly in terms of generalization, interpretability, and alignment with human emotional perception.

References

✔️ Music Emotion Classification Method Based on Deep Learning and Improved Attention                  Mechanism, Computational Intelligence and Neuroscience, 2022
✔️ Music Emotion Recognition Based on Deep Learning: A Review, IEEE Access / IJACSA, 2024

This project presents and analyzes the seminal paper “The Anatomy of a Large-Scale Hypertextual Web Search Engine” by Sergey Brin and Lawrence Page (1998). The presentation focuses on the PageRank algorithm and its role in enabling scalable and effective web search by leveraging the link structure of the World Wide Web.

Objectives

The objective of this project is to explain the theoretical foundations and practical motivations behind PageRank as a link-based ranking algorithm.

Results

The presentation was completed and delivered, clearly illustrating the intuition, mathematical formulation, and iterative computation of PageRank. Through examples and visualizations, the project demonstrated how link analysis enhances ranking quality in large-scale information retrieval systems. The work provided audiences with a solid understanding of why PageRank represented a breakthrough in web search technology. 

References

✔️ The Anatomy of a Large-Scale Hypertextual Web Search Engine (by Sergei Brin and              Lawrence Page)

This project presents and reviews the influential paper “A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting”. The presentation introduces the Adaptive Boosting (AdaBoost) algorithm and its role in improving classification performance through ensemble learning.

Objectives

The goal of this project is to explain the theoretical principles underlying AdaBoost, including weighted training samples, weak learner assumptions, and exponential loss minimization.

Results

The presentation was completed and successfully conveyed the intuition, algorithmic steps, and mathematical formulation of AdaBoost. Comparative examples demonstrated how boosting improves classification accuracy and robustness over single models. The project highlighted the long-term influence of AdaBoost on ensemble methods and modern machine learning practice.

References

✔️ A Decision-Theoretic Generalization of On-Line Learning and an Application to                   Boosting (by Yoav Freund and Robert E. Schapire)

This project serves as an advanced interdisciplinary research initiative combining Music Information Retrieval, affective computing, neuroscience, and recommendation systems. It explores emotion-based music classification and recommendation using audio signals, lyrics, metadata, and neurophysiological signals, with a particular focus on accessibility and personalization.

Objectives

The primary objective is to design a comprehensive music intelligence framework capable of understanding and modeling emotional responses to music across different modalities. The project aims to (1) classify vocal, instrumental, and soundtrack music using emotion models beyond traditional frameworks, (2) incorporate multilingual lyric understanding using transformer-based language models, (3) explore EEG-based listener–music alignment, (4) support deaf users through emotion-to-visual or haptic translation, and (5) enable advanced applications such as vocal training, talent assessment, chord extraction, and artist-aware recommendation systems.

Results

The project is currently in the conceptual design and early prototyping phase. The system architecture has been defined, including modular pipelines for audio analysis, lyric-based emotion modeling, EEG signal processing, and recommendation. Initial experiments with audio and text embeddings demonstrate the feasibility of multimodal emotion representation, and further development will focus on real-time integration, evaluation, and user-centered validation.

References

✔️ Python 3

This verification assignment, supervised by Prof. Sherry (Shaghayegh) Sahebi, applied a simplified Performance Factor Analysis (PFA) model to simulate student learning activities. The project focused on the Persian language and literature domain and served as a test case for transfer learning techniques in educational modeling.

Objectives

The objective was to verify the functionality of the simplified PFA model by simulating realistic student performance data. The initial situation required modeling learning patterns without a large real-world dataset.

Results

The model successfully simulated student activity sequences, demonstrating how PFA can adapt to a specific language and curriculum. Results indicated that even a simplified version of PFA could capture learning trends and predict performance with reasonable accuracy. This verification will support future applications in personalized education and adaptive testing.

References

✔️ Python 3

Assigned as part of an AI Engineer recruitment assessment for payever GmbH, this task involved classifying products into self-defined categories such as House, Gaming, and Healthcare using a Multi-Layer Perceptron neural network implemented in Python 3. 

Objectives

The goal was to design and train a neural network capable of accurately categorizing a small product dataset into predefined groups. The categories were self-initiated and the model was trained for 12 epochs with the Adam optimizer to explore its classification performance.

Results

The model achieved nearly 100% accuracy due to the simplicity and limitations of the dataset—specifically, the fact that the training and testing data were identical! While the task demonstrated the implementation and execution of a neural network for classification, the unusually high accuracy reflected the overfitting caused by the dataset structure rather than a generalizable model.

References

✔️ payever GmbH

✔️ Python 3

This project replaces the final project for a Machine Learning or Natural Language Processing course and focuses on emotion and sentiment analysis of Persian tweets. It combines traditional feature-based methods with contextual embeddings derived from ParsBERT and deep neural architectures.

Objectives

The objective is to develop an emotion classification system capable of identifying and categorizing emotional states expressed in Persian Twitter texts. The project emphasizes rigorous data preprocessing, visualization of emotion class distributions, tokenization and embedding using ParsBERT, and the comparison of CNN, LSTM, and hybrid CNN–LSTM models. Evaluation strategies include macro, micro, and weighted averaging to address class imbalance.

Results

Dataset preprocessing and exploratory analysis have been completed, including emotion distribution visualization and preprocessing validation. Initial experiments demonstrate that ParsBERT embeddings significantly improve classification performance over Bag-of-Words baselines. Hybrid CNN–LSTM models show promising results in balancing local feature extraction and sequential dependency modeling, with further hyperparameter optimization underway.

References

✔️ Persian Tweets Emotional Dataset

✔️ Python 3

This freelancing project involves designing an author identification system for Persian texts using large language models (LLMs) such as ParsBERT and ParsGPT2. The dataset was self-collected and the implementation is in Python 3. The work involves both classification and comparative analysis of different LLM architectures.

Objectives

The aim is to determine which LLM provides better performance for Persian author attribution. Initially, there was no standard benchmark for this task in Persian, so data collection and preprocessing were required. Key considerations include ensuring dataset diversity, managing computational requirements, and maintaining model fairness across different authors.

Results

As the project is ongoing, current findings suggest that ParsGPT2 shows competitive performance in capturing stylistic nuances, while ParsBERT excels in token-level contextual understanding. The final evaluation will compare models using metrics such as F1-score, accuracy, and recall to recommend the most effective approach.

References

✔️ ParsBERT

✔️ ParsGPT2

✔️ Python 3

This bachelor project, supervised by Prof. Hedieh Sajedi, applied transfer learning for Persian language and literature using a self-collected dataset. Implemented in Python 3 with Hazm, Pandas, scikit-learn, and Hugging Face Transformers, it involved fine-tuning ParsBERT for author classification.

Objectives

The goal was to classify Persian text files for author identification by leveraging a pre-trained language model. The challenge was the absence of a suitable dataset, which required manual collection. Key considerations included optimizing token length, batch sizes, and preventing overfitting while maintaining accuracy.

Results

ParsBERT was fine-tuned with a maximum token length of 128, batch sizes of 8 (training) and 4 (validation), for 5 epochs. Learning rate was set to 2e-5 using Adam optimization with Sparse Categorical Cross Entropy loss. Using 5-fold cross-validation, the model achieved a mean F1-score of 91.8%, demonstrating strong performance for Persian author attribution.

References

✔️ ParsBERT

✔️ Python 3

This final project for the Bio-Computing course, supervised by Prof. Bagher BabaAli, focused on generating captions for images using a hybrid CNN-LSTM model. The Flickr dataset was sourced from Kaggle, and the implementation was in Python 3 with PyTorch, ResNet18, and Word2Vec. 

Objectives

The objective was to explore hybrid deep learning architectures for image captioning. The initial dataset consisted of images with text captions, requiring preprocessing to build a vocabulary and extract visual features. Considerations included whether to freeze or unfreeze CNN layers, embedding size selection, and balancing training time with accuracy.

Results

A vocabulary was developed using Word2Vec, and a CNN-LSTM hybrid was trained. ResNet18 was tested with frozen and unfrozen layers, with the fully trainable version yielding the best results: 300-word embeddings, 256 hidden LSTM nodes, 20 epochs, batch size 4, Adam optimizer, and Cross Entropy loss ≈1.9. Training on Kaggle's GPU T4 x2 achieved more accurate and descriptive captions.

References

✔️ Flickr Dataset

✔️ Python 3

This final project for the Data Mining course, supervised by Prof. Hedieh Sajedi, analyzed daily climate data for Delhi from Kaggle. Implemented in Python 3 with TensorFlow, Keras, and scikit-learn, it compared statistical and deep learning methods for forecasting.

 Objectives

The goal was to model and predict climate patterns using various sequence-sensitive models, including ARIMA, Prophet, and recurrent neural networks. Considerations included model interpretability, computational constraints, and balancing bias and variance for regression tasks.

Results

The Bidirectional GRU (BiGRU) model achieved the highest R² score (≈0.9325). It was trained with one hidden layer (ReLU activation), batch size 5, 75 epochs, 20% validation split, Adam optimizer, and MSE loss. The ability of BiGRU to learn in both directions proved highly effective for time series forecasting.

References

✔️ Daily Delhi Climate Dataset

✔️ Python 3

This cancelled homework assignment for the Bio-Computing course aimed to solve the Travelling Salesman Problem (TSP) using Self-Organizing Maps (SOM). The project was written in Python 3.

Objectives

The aim was to explore an unsupervised learning approach to an NP-hard optimization problem. The plan involved adapting SOMs to find an optimal tour through a set of cities by minimizing total distance.

Results

The project is currently incomplete and remains in the planning phase, with preliminary research into SOM adaptations for TSP showing potential for application in logistics and routing problems.

References

✔️ Python 3

This fifth project for the Advanced Information Retrieval course, supervised by Prof. Bagher BabaAli, applied a hybrid modeling approach to movie review sentiment classification. It combined traditional methods like Naïve Bayes with advanced embeddings and latent semantic techniques.

Objectives

The aim was to improve classification accuracy by integrating multiple techniques: Word2Vec, GloVe, FastText embeddings, Latent Semantic Analysis (LSA), and Support Vector Machines (SVM). The challenge was to effectively merge semantic features with traditional classifiers.

Results

A vocabulary was built using three embedding models, LSA was applied using Singular Value Decomposition, and results were combined with SVM. The hybrid LSA-SVM model was compared to Naïve Bayes, showing higher classification accuracy, validating the effectiveness of combining statistical and semantic approaches for text classification.

References

✔️ An Introduction to Information Retrieval (by Christopher D. Manning, Prabhakar                  Raghavan, and Hinrich Schütze)

✔️ Large Movie Review Dataset

✔️ Python 3

This sixth homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, focused on classifying handwritten digits from the MNIST dataset using convolutional neural networks (CNNs) and transfer learning with VGG16 in Python 3.

Objectives

The goal was to develop and train a CNN and a fully connected layer of a pretrained VGG16 model for digit classification. Considerations included filter sizes, pooling layers, overfitting prevention, cross-validation, and limited computational resources.

Results

The CNN achieved over 80% accuracy, significantly outperforming VGG16 (~17% accuracy) due to limited training epochs. A 5-fold cross-validation approach optimized filter sizes, while dropout layers were unnecessary due to stable training. The results demonstrated the effectiveness of custom CNNs over transfer learning for small datasets.

References

✔️ VGG16 Model

✔️ MNIST Dataset

✔️ Python 3

This fifth homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, focused on feature extraction with an autoencoder and classification using a multi-layer perceptron (MLP).

Objectives

The objective was to extract prominent features from MNIST images using an autoencoder and then classify the digits with an MLP. Considerations included batch size, validation splits, fine-tuning, and proper activation functions.

Results

The autoencoder extracted features with a batch size of 500 over 15 epochs, which were then fed into a two-hidden-layer MLP classifier. The model achieved approximately 60% accuracy, showing moderate success in combining feature extraction and MLP classification.

References

✔️ MNIST Dataset

✔️ Python 3

This fifth homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, implemented a shallow neural network (SNN) for binary classification in Python 3.

Objectives

The goal was to train a one-layer neural network from scratch using 1000 hidden nodes. Considerations included choosing activation functions, initializing weights with the Newgen-Widrow algorithm, and applying the Delta-Bar-Delta algorithm with momentum for learning rate updates.

Results

The network successfully classified bipolar binary data using the MSE loss function and backpropagation. The model demonstrated the ability to efficiently learn from input data, validating the effectiveness of classic neural network training algorithms.

References

✔️ Python 3

This fourth homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, implemented a primitive neural network to verify a Deterministic Finite Automata (DFA) with four states.

Objectives

The goal was to use McCulloch–Pitt neural network models for DFA verification. Considerations included accurate modeling of neural thresholds and state transitions.

Results

The network correctly verified the DFA, and all calculations were documented in 'Calculations.pdf'. This demonstrated the neural network's ability to simulate finite automata logic.

References

✔️ Python 3

This fourth homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, implemented ridge regression with polynomial features to classify a unidimensional dataset.

Objectives

The goal was to train a hyperplane using the perceptron algorithm while preventing overfitting via regularization in a 4th-degree polynomial regression. Considerations included choosing an appropriate loss function (MSE) and tuning regularization strength.

Results

The model successfully classified the dataset with improved training and test accuracy. Regularization reduced overfitting and ensured better generalization.

References

✔️ Python 3

This fourth homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, implemented a perceptron algorithm in Python 3 to classify a bidimensional dataset.

Objectives

The goal was to train a basic perceptron for binary classification, with consideration of feature scaling, learning rates, and visualizing the decision boundary.

Results

The perceptron accurately classified the dataset and produced visualizations of the decision boundaries, validating the algorithm's functionality on small datasets.

References

✔️ Python 3

This third homework assignment for the Data Mining course, supervised by Prof. Hedieh Sajedi, used autoencoder feature extraction followed by clustering on MNIST digits.

Objectives

The goal was to apply partitional (K-Means, Mini Batch K-Means) and hierarchical (DBSCAN, HDBSCAN) clustering on encoded MNIST features. Considerations included hyperparameter tuning, cluster validation, and test data partitioning.

Results

Clustering models were trained and fine-tuned, with 35% of test data used for validation. The results demonstrated successful grouping of digits with both partitional and hierarchical approaches, validating autoencoder-based feature extraction for unsupervised tasks.

References

✔️ MNIST Dataset

✔️ Python 3

This second homework assignment for the Data Mining course, supervised by Prof. Hedieh Sajedi, focused on binary classification of income levels using multiple models.

Objectives

The goal was to classify adult census data into ≤50k or >50k income categories. Key considerations included dataset balancing, feature selection, PCA for dimensionality reduction, and hyperparameter optimization.

Results

Four models were tested: KNN (78.6%), SVM (79.3%), Naïve Bayes (~75%), and MLP (79.6%). MLP performed best, demonstrating the importance of feature engineering and hyperparameter tuning in binary classification tasks.

References

✔️ Adult Census Income Dataset

✔️ Python 3

This final project for the Non-Linear Programming course, supervised by Prof. Majid Soleimani Damaneh, implemented the gradient projection method to explore feasible regions including balls, boxes, and positive real numbers in Python 3.

Objectives

The goal was to solve constrained optimization problems by projecting gradients onto feasible regions. Considerations included proper handling of boundary conditions and efficient implementation of projections.

Results

The method successfully solved various test problems, demonstrating its ability to handle constraints efficiently in non-linear optimization tasks.

References

✔️ Introduction to Nonlinear Optimization: Theory, Algorithms, and Applications with               MATLAB (by Amir Beck)

✔️ Python 3

This final project for the Non-Linear Programming course, supervised by Prof. Majid Soleimani Damaneh, applied quadratic regularization for step signal denoising in Python 3.

Objectives

The goal was to reduce noise in step signals using quadratic regularization and analyze the corresponding dual problem. Key considerations included stability, convergence, and accuracy of denoised signals.

Results

The method effectively denoised step signals and provided insights into dual problem solutions, validating the approach for signal processing applications.

References

✔️ Introduction to Nonlinear Optimization: Theory, Algorithms, and Applications with               MATLAB (by Amir Beck)

✔️ Python 3

This final project for the Non-Linear Programming course, supervised by Prof. Majid Soleimani Damaneh, implemented the backtracking gradient algorithm in Python 3.

Objectives

The goal was to solve non-linear problems using a backtracking gradient approach. Considerations included selecting step size constants and evaluating convergence behavior.

Results

The algorithm successfully solved sample problems, demonstrating sensitivity to the choice of hyperparameters and illustrating the method’s efficiency for non-linear optimization.

References

✔️ Introduction to Nonlinear Optimization: Theory, Algorithms, and Applications with               MATLAB (by Amir Beck)

✔️ Python 3

This final project for the Non-Linear Programming course, supervised by Prof. Majid Soleimani Damaneh, implemented a support vector machine (SVM) in MATLAB to solve complex non-linear problems.

Objectives

The goal was to develop an SVM algorithm from scratch for classification tasks. Considerations included kernel selection, margin maximization, and solving the quadratic optimization problem efficiently.

Results

The SVM successfully solved benchmark non-linear classification problems, demonstrating the algorithm’s functionality and practical applicability.

References

✔️ Introduction to Nonlinear Optimization: Theory, Algorithms, and Applications with               MATLAB (by Amir Beck)

✔️ MATLAB

This first homework assignment for the Data Mining course, supervised by Prof. Hedieh Sajedi, focused on binary classification of mushroom data using decision trees in Python 3.

Objectives

The goal was to classify mushrooms as edible or poisonous. Considerations included dataset preprocessing, feature selection, and hyperparameter tuning using Grid Search and Randomized Search techniques.

Results

Decision tree models were trained and fine-tuned, successfully achieving high accuracy and demonstrating effective feature-based classification.

References

✔️ Mushroom Classification Dataset

✔️ Python 3

This fourth project for the Advanced Information Retrieval course, supervised by Prof. Bagher BabaAli, implemented document ranking using various IR models in Python 3.

Objectives

The goal was to create a retrieval system using language models, probabilistic models, and vector space models. Considerations included efficient ranking, indexing, and performance evaluation.

Results

The system successfully retrieved and ranked documents using the 'Cranfield' collection, with Okapi BM25 and TF-IDF implementations providing accurate and relevant results.

References

✔️ An Introduction to Information Retrieval (by Christopher D. Manning, Prabhakar                  Raghavan, and Hinrich Schütze)

✔️ Cranfield Collection Dataset

✔️ Python 3

This third project for the Advanced Information Retrieval course, supervised by Prof. Bagher BabaAli, implemented the Block Sorted-Based Indexing (BSBI) algorithm with Elias Gamma coding in Python 3.

Objectives

The goal was to efficiently construct inverted indexes for large datasets. Considerations included handling disk storage, encoding/decoding performance, and scalability.

Results

The BSBI algorithm successfully built inverted indexes, with Elias Gamma coding optimizing storage efficiency. The project demonstrated practical indexing strategies for large text collections.

References

✔️ An Introduction to Information Retrieval (by Christopher D. Manning, Prabhakar                  Raghavan, and Hinrich Schütze)

✔️ Python 3

This second project for the Advanced Information Retrieval course, supervised by Prof. Bagher BabaAli, implemented an IR system in Python 3 with spelling correction and wildcard query handling.

Objectives

The goal was to enhance retrieval accuracy by minimizing Levenshtein distance for spelling errors and supporting wildcard queries via bigram indexing. Considerations included efficiency and precision of retrieval results.

Results

The system successfully handled both spelling corrections and wildcard queries, improving overall search accuracy and usability for text retrieval tasks.

References

✔️ An Introduction to Information Retrieval (by Christopher D. Manning, Prabhakar                  Raghavan, and Hinrich Schütze)

✔️ Python 3

This first project for the Advanced Information Retrieval course, supervised by Prof. Bagher BabaAli, implemented Boolean and proximity queries in Python 3.

Objectives

The goal was to construct an inverted index and optimize search performance for advanced Boolean queries. Considerations included index organization, postings list management, and query evaluation speed.

Results

The IR system effectively processed complex Boolean and proximity queries, demonstrating practical indexing and retrieval techniques.

References

✔️ An Introduction to Information Retrieval (by Christopher D. Manning, Prabhakar                  Raghavan, and Hinrich Schütze)

✔️ Python 3

This second homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, addressed the Set Covering Problem (SCP) using the Max-Min Ant System (MMAS) in Python 3.

Objectives

The goal was to find optimal or near-optimal solutions to SCP instances using a metaheuristic approach. Considerations included pheromone update strategies, convergence behavior, and solution quality.

Results

The MMAS algorithm successfully generated high-quality solutions for the SCP dataset provided by OR-Library, demonstrating the effectiveness of ant colony optimization techniques in combinatorial problems.

References

✔️ OR-Library Dataset (by J E Beasley)

✔️ Python 3

This third homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, applied Particle Swarm Optimization (PSO) to find global maxima and minima of multivariable functions in Python 3.

Objectives

The goal was to optimize complex multivariable functions by exploring global search strategies. Considerations included swarm size, inertia weight, and cognitive/social parameters for convergence.

Results

PSO successfully located global maxima and minima with values (-8.0674, -9.6533, 19.2057) and (-28.2161, -88.6436, -138702483.5977), demonstrating its ability to efficiently explore the solution space.

References

✔️ Python 3

This third homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, implemented Particle Swarm Optimization (PSO) and Simulated Annealing (SA) to solve the Quadratic Assignment Problem (QAP).

Objectives

The goal was to apply two metaheuristic algorithms to an NP-hard problem. Considerations included parameter tuning (inertia, cognitive, social coefficients) and hyperparameter initialization for SA.

Results

Both PSO and SA were implemented and fine-tuned successfully, demonstrating effective solution search for QAP instances in Python 3.

References

✔️ Python 3

This second homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, applied ant colony optimization variants for Supply Chain Optimization (SCO) using Python 3.

Objectives

The goal was to optimize supply chain routes using Independent Ant Colonies (IAC), Parallel Ants (PA), and Parallel Ants with Vectorization (PAwV). Considerations included multithreading, computation speed, and solution quality.

Results

All three methods successfully generated optimized supply chain solutions using the dataset from Brunel University London, with parallel approaches improving computational efficiency.

References

✔️ Supply Chain Logistics Problem Dataset

✔️ Python 3

This first homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, implemented a Genetic Algorithm (GA) to solve the Travelling Salesman Problem (TSP) in Python 3.

Objectives

The goal was to find near-optimal tours in TSP instances. Considerations included selection, crossover, mutation operators, and convergence criteria.

Results

The GA successfully generated efficient routes for TSP instances, demonstrating the applicability of evolutionary algorithms to combinatorial optimization problems.

References

✔️ Python 3

This first homework assignment for the Bio-Computing course, supervised by Prof. Bagher BabaAli, implemented curve fitting using Genetic and Memetic Algorithms in Python 3.

Objectives

The goal was to fit a curve to data points using optimization-based approaches. Considerations included neighbor generation strategies for Memetic Algorithms and convergence speed.

Results

Both Genetic and Memetic Algorithms produced accurate curve fits, validating the hybrid optimization approach for regression problems.

References

✔️ Python 3

This final project for the Artificial Intelligence course, supervised by Prof. Hedieh Sajedi, implemented a 4-Connect game AI using the Minimax algorithm.

Objectives

The goal was to design an AI capable of optimal decision-making in 4-Connect. Considerations included evaluation functions, search depth, and computational efficiency.

Results

The Minimax-based AI successfully played 4-Connect with competitive performance, demonstrating practical applications of game-tree search algorithms.

References

✔️ Artificial Intelligence: A Modern Approach (by Stuart Russell and Peter Norvig)

✔️ Python 3

This second homework assignment for the Artificial Intelligence course, supervised by Prof. Hedieh Sajedi, compared multiple pathfinding algorithms for solving the 8-Puzzle problem in Python 3.

Objectives

The goal was to evaluate the performance of A*, Breadth First Search (BFS), Depth First Search (DFS), Iterative Deepening Search (IDS), and Uniform Cost Search (UCS) algorithms on 8-Puzzle. Considerations included search efficiency, path optimality, and memory usage.

Results

All algorithms solved the puzzle with varying efficiency; A* performed best in terms of speed and optimality, providing insight into the strengths and limitations of different search strategies.

References

✔️ Artificial Intelligence: A Modern Approach (by Stuart Russell and Peter Norvig)

✔️ Python 3

This first homework assignment for the Artificial Intelligence course, supervised by Prof. Hedieh Sajedi, implemented a reinforcement learning agent using Q-Learning to navigate mazes in Python 3.

Objectives

The goal was to train an agent to learn optimal paths via rewards and penalties. Considerations included learning rate, exploration strategy, and convergence of Q-values.

Results

The Q-Learning agent successfully solved various mazes, illustrating reinforcement learning principles and adaptive decision-making in unknown environments.

References

✔️ Artificial Intelligence: A Modern Approach (by Stuart Russell and Peter Norvig)

✔️ Python 3

This project compiles a collection of homework assignments (from the exercises of the refence book chapters) and a final practical project about Soil Engineering for the Mathematics Laboratory course, supervised by Prof. Arta AmirJamshidi, implemented using MATrix LABoratory (MATLAB). The work focuses on numerical computation, mathematical modeling, visualization, and algorithmic problem-solving through hands-on programming exercises.

Objectives

The objective of this project was to strengthen the understanding of mathematical concepts through computational implementation. Emphasis was placed on translating theoretical mathematics into executable MATLAB code, analyzing numerical behavior, and visualizing results. The assignments aimed to enhance skills in numerical methods, matrix operations, function approximation, and algorithmic experimentation within a laboratory-oriented learning environment.

Results

The homework assignments and final project were successfully completed, demonstrating accurate implementation of mathematical models and numerical algorithms. Through systematic coding, simulation, and visualization, the project provided practical insight into mathematical problem-solving and reinforced the connection between theory and computation.

References

✔️ An Introduction to Programming and Numerical Methods (by James P. Denier and                Stephen Robert Otto)

✔️ MATLAB

This three-phase project for the Database course, supervised by Prof. Marjan Goodarzi, simulated Coursera’s specialization SQL sub-database in Python 3.

Objectives

The goal was to implement normalization, minimize dependency and redundancy, and design entity-relationship (ER) diagrams. Considerations included query accuracy, record generation, and database consistency.

Results

The database simulation successfully executed queries and maintained normalized structures, demonstrating practical skills in database design and management.

References

✔️ Coursera Inc.

✔️ Structured Query Language (SQL)

This final project for the Machine Language and Assembly course, implemented a basic smart house control system using C, Arduino, and Proteus Design Suite.

Objectives

The goal was to control and automate household devices. Considerations included sensor integration, hardware-software communication, and real-time control.

Results

The system successfully automated household functions, demonstrating foundational knowledge in embedded systems and smart device programming.

References

✔️ AVR Microcontroller & Embedded Systems Using Assembly & C (by Muhammad Ali       Mazidi, Sarmad Naimi, and Sepehr Naimi)

✔️ C

This final project for the Fundamentals of Operating System course, supervised by Prof. Ali Khalilian, simulated CPU scheduling algorithms in Python 3.

Objectives

The goal was to implement FCFS and SJF scheduling for process management. Considerations included process arrival times, burst times, and accurate computation of turnaround and waiting times.

Results

The simulations successfully demonstrated the performance differences between FCFS and SJF, validating theoretical CPU scheduling concepts.

References

✔️ Operating System Concepts (by Abraham Silberschatz, Peter Baer Galvin, and Greg       Gagne)

✔️ Python 3

This collection of final projects for Strategic Games I (Game Theory) and Scientific Writing courses, supervised by Prof. Prof. Morteza Mohammad-Noori and Prof. Mehdireza Darvishzade, applied game theory to model liver transplantation processes using LaTeX (Beamer, Xepersian).

Objectives

The goal was to analyze strategic interactions and optimize decision-making. Considerations included fairness, resource allocation, and modeling collaborative behavior.

Results

The project produced a practical research paper in LaTeX, providing insights into decision-making processes in medical transplantation systems.

References

✔️ Health Care and Game Theory - An application to liver transplantation

✔️ XePersian

✔️ LaTeX

This final project for the Scientific Computing (Numerical Linear Algebra) course, supervised by Prof. Arta AmirJamshidi, applied linear algebra concepts to voting theory using Python 3.

Objectives

The goal was to verify matrix operations and model voting behavior. Considerations included vector manipulation, matrix computation, and ensuring mathematical correctness.

Results

The project successfully demonstrated the application of linear algebra in voting scenarios, validating theoretical concepts with computational experiments.

References

✔️ Numerical Linear Algebra and Applications, 2nd Edition (by Biswa Nath Datta)

✔️ Linear Algebra (by Stephen H. Friedberg, Arnold Insel, and Lawrence Spence)

✔️ Python 3

This project compiles a collection of homework assignments and practical projects for Machine Language and Assembly course, supervised by Prof. Fazel (Abolfazl) Nadi, implemented in x86 Assembly language using the NASM (Netwide Assembler) architecture. It focuses on low-level programming concepts, system interaction, and performance-oriented computation.

Objectives

The goal was to simulate components of a computer system based on M. Morris Mano’s "Computer System Architecture". Considerations included proper logic design and accurate implementation of instruction execution.

Results

The simulation successfully demonstrated fundamental computer organization principles, providing a hands-on understanding of system architecture.

References

✔️Digital Logic and Computer Design & Computer System Architecture (by M. Morris       Mano)

✔️ Logisim (by Carl Burch)

This final project for the Principles of Computer Systems course, supervised by Prof. Fazel (Abolfazl) Nadi, implemented basic computer architecture simulations using Logisim.

Objectives

The goal was to simulate components of a computer system based on M. Morris Mano’s "Computer System Architecture". Considerations included proper logic design and accurate implementation of instruction execution.

Results

The simulation successfully demonstrated fundamental computer organization principles, providing a hands-on understanding of system architecture.

References

✔️Digital Logic and Computer Design & Computer System Architecture (by M. Morris       Mano)

✔️ Logisim (by Carl Burch)

This final project for Fundamentals of Combinatorics course, supervised by Prof. Morteza Mohammad-Noori, is a theoretical and educational presentation introducing spanning trees and graph minimization algorithms, with a focus on their foundational role in Computer Science and network optimization.

Objectives

The goal is to explain the concept of spanning trees and the importance of minimizing total edge weight in graphs. The project introduces classical algorithms such as Kruskal’s and Prim’s algorithms, discusses their computational complexity, and demonstrates their applications in network design, routing, and optimization problems.

Results

The presentation was completed and provided a clear conceptual understanding of spanning trees and minimum spanning tree algorithms. Through illustrative examples and step-by-step explanations, the project effectively conveyed algorithmic intuition and practical relevance.

References

✔️ Python 3

This final project for Introduction to Economics course, supervised by Prof. Kianmehr, consists of an analytical presentation examining the economic factors contributing to brain drain and elite migration in Iran. It explores how macroeconomic conditions influence the decisions of highly skilled individuals to migrate, with an emphasis on long-term national and individual impacts.

Objectives

The primary objective is to analyze and present the economic mechanisms behind skilled migration, including unemployment, income disparities, inflation, limited research funding, and lack of professional growth opportunities. The project aims to contextualize these factors within Iran’s economic environment and compare them with global labor market dynamics, providing an evidence-based narrative suitable for academic discussion.

Results

The presentation was completed and delivered, synthesizing economic data, academic literature, and policy-oriented analysis. The findings highlight strong correlations between economic instability and elite migration decisions, and emphasize the long-term consequences for innovation, education, and economic development. The project successfully communicates complex economic concepts in a structured and accessible format.

References

✔️ Python 3

This collection of final projects for Fundamentals of Computer Science and Advanced Programming courses, supervised by Prof. Zaynab Mousavianhor and Prof. Amirhoushang Hoseinpour Dehkordi, implemented five board games in Python 3.

Objectives

The goal was to develop single-player and multiplayer (up to four players) games, including Flowers or Absurd, Quoridor, Rock Paper Scissors, Snake, and Tic-Tac-Toe. Considerations included game rules, user interface, and player interactions.

Results

All games were implemented successfully, demonstrating programming skills, game logic development, and handling of multiple game modes.

References

✔️ Python 3