This is a self-assigned project aimed at building a system capable of classifying music tracks based on emotions across multiple languages. The idea emerged from my interest in combining natural language processing, music information retrieval, and affective computing. The project is being conducted independently, without external supervision, allowing me to fully explore experimental approaches and model designs.

Objectives

The main goal is to design a multilingual classification model that can interpret emotional cues from both lyrics and audio features. Initially, there was no ready-made multilingual emotional music dataset, so part of the work includes collecting and preprocessing data. Key considerations include handling linguistic differences, normalizing emotion labels across cultures, and extracting relevant audio and textual features.

Results

The project is ongoing. Current progress includes preliminary dataset collection, initial feature extraction, and prototype model testing. Early experiments show promise, particularly with transformer-based multilingual models for lyrics and convolutional architectures for audio. The final system is expected to provide accurate emotion classification for songs in multiple languages, with potential applications in music recommendation engines and emotional well-being tools.

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

✔️ 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 project replaced the final project for the Bio-Computing course and focuses on sentiment analysis of Persian texts using a hybrid approach combining Bag of Words and ParsBERT.

Objectives

The aim is to develop a sentiment classifier capable of understanding Persian language nuances. Considerations include dataset quality, model selection, preprocessing, and integration of multiple text representation methods.

Results

The project is ongoing, with dataset preprocessing completed. Initial experiments show promising sentiment classification results using ParsBERT embeddings and hybrid modeling strategies.

References

✔️ Persian Tweets Emotional Dataset

✔️ 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*, BFS, DFS, IDS, and 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 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 final project for the Scientific Writing course, supervised by Prof. Morteza MohammadNoori, 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 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 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