Amin

The project encompasses two key components:

• Automated Reconnaissance Method: Developed an efficient reconnaissance methodology including subdomain brute force techniques. This involves parsing Merkle Trees utilized by Certificate Authorities to store SSL/TLS certificates. The approach ensures a broad and accurate identification of subdomains.
• Watch Tower System: Created a sophisticated monitoring system to track changes in website infrastructure. Integrated with the Discord platform to provide real-time alerts and updates on asset changes. Built with well-structured GraphQL APIs and optimized PostgreSQL queries to handle data efficiently. The system is implemented in GoLang with multi-threaded efficiency for optimal performance.

The project implements the Raft consensus algorithm to achieve fault tolerance in distributed systems. It includes concurrency features to handle multiple operations simultaneously and uses Docker containers to create an isolated environment for each component. MongoDB is employed for managing logs, ensuring data consistency and facilitating uninterrupted leader election.

This project centers around an advanced auto-trader bot developed in Python. The bot operates by interpreting and executing trading signals provided by traders. It is designed to automate trading decisions and manage trades with minimal human intervention. The key features include:

• Signal-Based Trading: The bot listens to trading signals from various sources and executes trades according to predefined strategies. These signals can be based on technical indicators, market trends, or other trading algorithms.
• Exchange Integration: Integrated with several cryptocurrency exchanges, including KuCoin, to facilitate trading. The bot interacts with these platforms using their APIs to place orders, monitor market conditions, and manage portfolios.
• Error Handling and Logging: Implemented robust error handling and logging mechanisms to ensure the bot operates smoothly and any issues are promptly addressed. Logs provide insights into trading activities and performance.
• Scalability: Designed with scalability in mind, allowing the bot to be adapted for use with additional exchanges or modified trading strategies as needed.

The goal is to color the map of continents such that no two adjacent countries have the same color. You can define the Neighborhood-distance parameter to specify the threshold for neighboring elements. For example, setting the Neighborhood-distance to 2 includes the neighbors of neighbors within the defined neighborhood.

The Maze Solver project explores and compares five popular search algorithms for solving a maze: DFS, BFS, IDS, A*, and A* Geometric. The maze is represented as a 2D grid where each cell can either be an open path, a wall, or the goal. The algorithms navigate the maze to find the most efficient path based on different criteria and heuristics. Geometric A* is an improvement on the traditional A* algorithm, offering enhanced efficiency, as described in the linked paper DOI: 10.1109/ACCESS.2021.3070054.
This project also serves as a template for students enrolled in an Artificial Intelligence course, enabling them to explore the implementation and behavior of key pathfinding algorithms. Students can build upon this foundation, experimenting with different heuristics and techniques, or using the provided algorithms to solve various AI-driven search problems.

The 8-Puzzle Solver project demonstrates the application of heuristic search algorithms to solve the 8-puzzle, a classic problem in artificial intelligence. The puzzle consists of a 3x3 grid with eight numbered tiles and one empty space. The goal is to arrange the tiles in ascending order by sliding them into the empty space.
In this project, various heuristics are applied, including Manhattan Distance, Euclidean Distance, Number of Wrong Tiles, and their modifications, to guide the search process. These heuristics are integrated with algorithms like A* to find the most efficient solution. The project highlights how different heuristics influence the performance and outcome of solving the puzzle, providing a practical demonstration of heuristic-driven problem-solving.

The Pacman agent uses the Minimax algorithm to evaluate both Pacman's and the ghosts' possible moves, where Pacman acts as the maximizing player and the ghosts as the minimizing players. The algorithm recursively evaluates game states and selects actions that optimize Pacman's score while avoiding ghosts. The agent uses a custom evaluation function that considers factors like proximity to food, distance from the nearest ghost, whether ghosts are scared, and the current score.

This project implements a SAT solver in Python that parses and solves propositional logic expressions using logical operations like negation, conjunction, disjunction, and implication. The algorithm improves upon traditional exponential methods by operating in linear time through truth value propagation across the parse tree. In cases where it can't directly find a model, the algorithm employs heuristics to make guesses for unassigned variables. The project also provides features to visualize the parse tree and manage shared nodes using a Directed Acyclic Graph (DAG) format, making it an efficient and practical tool for solving SAT problems.

The MNIST GAN project begins by importing essential libraries like PyTorch, Torchvision, and others to handle image transformations and neural network operations. The dataset used is the MNIST dataset, containing 28x28 grayscale images of handwritten digits. The architecture comprises a discriminator network that distinguishes between real and fake images, and a generator network that learns to produce fake images that closely resemble the real ones. The training process involves alternating between training the discriminator and the generator using loss functions and optimizers like Adam.

During training, real samples are extracted from the MNIST dataset, while fake samples are generated by feeding random noise into the generator. These fake images are evaluated by the discriminator to improve the generator's ability to create realistic images. The project also visualizes generated fake images at each epoch.

The project implements KANs with a custom-built neural network structure, offering flexibility in designing layers and nodes. The Optimizer class implements gradient descent, allowing backpropagation through the network to minimize the loss. The implementation includes training the model over a series of epochs, applying the KAN to sample datasets to showcase its effectiveness.

Key Features

• Learnable Activation Functions: Activation functions are no longer fixed. Instead, they are learnable, dynamic functions applied to weights, offering greater flexibility.
• No Linear Weights: KANs eliminate linear weights and replace them with splines, which are univariate functions parametrized to adjust based on data and tasks.
• Accuracy and Efficiency: KANs offer higher accuracy and more efficient scaling than traditional MLPs, making them suitable for mathematical modeling and physics applications.
• Visualization: Easily visualize the network’s computational graph, allowing human users to interact with and interpret KAN’s operations.

In this project, I explore the impact of different position sizes on account balance performance using Python, Pandas, and Matplotlib for visualization. I begin by plotting account performance for two position sizes (70% and 10%) and observe that smaller position sizes tend to show more stable growth, while larger positions may lead to greater volatility and potential downtrends.

The key objective is to identify the most efficient position size that maximizes returns while minimizing risks. Using the GEKKO optimization suite, I formulate a mathematical model based on risk and reward (R&R), win rate, and other factors.

Visualization and Performance Analysis

• Position Sizing Comparison: I compare the performance of position sizes ranging from 10% to 60% using multiple plots, showing how each size affects balance growth.
• Optimization Results: Using the GEKKO optimization solver, I calculate the optimal position size for maximizing returns based on model assumptions, generating an optimal lambda value.
• Dynamic Visualization: The relative return per lambda is visualized, allowing users to understand the impact of different position sizes on their capital.