React / NextJS / TypeScript / MongoDB / NodeJS Portfolio

This Python code builds, trains, and evaluates a simple neural network using TensorFlow for binary classification. It starts by importing necessary libraries for data handling, preprocessing, and building neural networks. A small fictional dataset is created with features like age, salary, years of membership, and interest in a product, along with a target variable indicating if a purchase was made. The dataset is split into training and testing sets, and the features are normalized to improve neural network performance. The neural network is defined with one hidden layer of 8 neurons using a ReLU activation function and an output layer with a single neuron using a sigmoid activation function to predict whether a purchase will be made (binary classification). The model is compiled with the Adam optimizer, binary cross-entropy loss function, and accuracy as the metric. It is trained over 50 epochs with a batch size of 2. After training, the model is evaluated on the test set, and its accuracy is printed. Finally, the model predicts purchase probabilities for the test set, converts these probabilities into binary outputs (0 or 1), and compares them with the actual test values, printing the results.

How to Build and Run a Neural Network with TensorFlow - Complete Tutorial based on this project

Features:

• Data Preprocessing: The code handles a small, fictional dataset using Pandas. The dataset includes features like age, salary, years of membership, and interest in a product, with the target variable being whether a purchase was made.
• Training and Evaluation: The model is trained using the Adam optimizer, which is a widely-used optimization algorithm for deep learning, combined with the binary cross-entropy loss function, which is ideal for binary classification tasks.
• Prediction and Comparison: After training, the model predicts the probability of a purchase for each test instance.
• Logging Suppression: The line os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' is used to suppress TensorFlow's logging output, ensuring that only critical errors are shown, which makes the output cleaner during training and evaluation.

Main Technologies:

• TensorFlow is an open-source machine learning framework developed by Google. It's primarily used for building and training deep learning models, such as neural networks.
• Pandas is a powerful data manipulation and analysis library for Python. It is commonly used for working with structured data like tables (DataFrames).
• Scikit-learn is a comprehensive machine learning library that provides simple and efficient tools for data mining, data analysis, and machine learning.
• Neural networks are a class of machine learning algorithms modeled after the human brain. They are particularly useful for complex pattern recognition tasks like classification and regression.
• Python is a high-level programming language that is widely used for machine learning and data science due to its rich ecosystem of libraries like TensorFlow, Pandas, and Scikit-learn.

These technologies work together to create a complete machine learning pipeline that involves data handling, preprocessing, neural network creation, training, and evaluation.

Description of the Weather App Project.
This project is a simple web application that fetches and displays current weather information for a specified city. It is built using Python's Flask framework for the web application and uses the OpenWeatherMap API to retrieve weather data. The application is designed to be deployed with Waitress, a production-ready WSGI server.
Features:

• Flask Web Application: This handles routing, rendering templates, and processing user requests.
• OpenWeatherMap API Integration: This retrieves current weather data for a given city.
• Waitress Server: This serves the Flask application.

Main Technologies:

• Flask Framework: A lightweight WSGI web application framework in Python
• OpenWeatherMap API: A third-party service used to fetch current weather data based on city names.
• Waitress - WSGI Server: A production-ready WSGI server used to serve the Flask application.
• Requests - HTTP Library: A simple HTTP library in Python used to make API requests to the OpenWeatherMap API.
• Dotenv - Environment Variable Loader: A Python library used to load environment variables from a .env file, specifically the OpenWeatherMap API key.
• HTML Templates: HTML files used to create the user interface. These templates are rendered by Flask to display the web pages.

By combining these technologies, the application provides a seamless experience for users to retrieve and view current weather information for any city they input.

Description of the Madlibs Simple Game.
This MadLibs program is a text-based game where users are prompted to enter various types of words (such as nouns, adjectives, and verbs) which are then inserted into a pre-defined story template to create a humorous and often nonsensical narrative. The program randomly selects one of several MadLibs stories each time it is run.
Features:

• MadLibs Stories: The program contains multiple story templates, each with its own set of word prompts.
• User Input: The program collects various words from the user.
• Random Selection: A random MadLibs story is selected each time the program is executed.
• Output: The completed MadLibs story is printed to the console.

Main Technologies:

• Python: The primary programming language used to write the script.
• Random Module: Utilized to randomly select one of the available MadLibs stories.
• Formatted Strings (f-strings): Used for inserting user input into the story templates.

This structure allows for a fun and interactive way to create unique stories every time the program is run, based on the user's inputs and random story selection.

This Python program implements two number guessing games:
This Python program offers a simple yet interactive way to play number guessing games. The user can either guess a computer-generated number or have the computer guess a number they are thinking of. It leverages Python's random number generation capabilities and standard input/output for user interaction.
Features:

• User Guesses the Number: The computer randomly selects a number, and the user tries to guess it.
• Computer Guesses the Number: The user thinks of a number, and the computer tries to guess it based on the user's feedback.

Main Technologies:

• Python: The primary programming language used to write the program.
• Random Module: A Python module that generates random numbers, used to create unpredictable numbers for guessing.
• Standard Input/Output: Used for user interaction through the console.

The Rock-Paper-Scissors game is a classic and simple game where two players choose between rock, paper, and scissors.



The game follows these rules:

• Rock crushes scissors.
• Scissors cuts paper.
• Paper covers rock.

In this version of the game, you play against the computer (Python). The game provides a personalized experience by allowing you to enter your name and keeps track of the number of games played, your wins, and Python's wins.
How to Play:

• Run the script with your name as a command-line argument: `python script.py --name YourName`
• Enter your choice (1 for Rock, 2 for Paper, 3 for Scissors) when prompted.
• The game will display both your choice and the computer's choice.
• The game will announce the winner of each round and keep track of the scores.
• After each round, you can choose to play again or quit.
• The game ends with a thank you message when you decide to quit.

This Hangman game is a Python-based word-guessing game where the player attempts to guess a hidden word one letter at a time. The game begins by selecting a valid word randomly from a list, excluding words with spaces or hyphens. The player has a total of seven lives and can guess letters until they either reveal the entire word or run out of lives. Each incorrect guess reduces the player's lives, and the current state of the word and the player's remaining lives are visually represented using a dictionary of hangman images. The game provides feedback on guessed letters, prompts for new guesses, and concludes with either a congratulatory message for guessing the word correctly or a message revealing the word if the player runs out of lives.

The code implements a simple Tic-Tac-Toe game, allowing a human player to play against a computer player that makes random moves. The game logic is encapsulated within the TicTacToe class, and the play function orchestrates the gameplay. The HumanPlayer and RandomComputerPlayer are assumed to be defined in an external module named player.

When you run the script, the game starts and prints the board with numbers. The human player is prompted to make a move by selecting a square number. The computer then makes a random move. The game alternates between the human and computer players until there is a winner or the board is full, resulting in a tie.