🏃 Ceptron-mov is a study project that aims to apply Machine Learning and Data Science concepts to build a human-machine interface that is capable of identifying human physical movements.

📺 https://www.youtube.com/watch?v=CSnNmrJZ-oU&t=4s

obs: The results spoken in the video are in Portuguese (pt-BR). The labels of movements in the dataset as well.

• Introduction
• Technology
• Dependencies
• Project Structure
• Flow

The availability of a system capable of automatically classifying the physical movements performed by a human being is extremely attractive for many health monitoring applications and for the development of advanced man-machine communication interfaces. When we speak of physical movements, I mean whether the person is sitting, lying down, walking, running, pedaling, and so on.

Information on physical movements is valuable as a source of contextual knowledge. If this information were available, the interaction between man-machine would be richer. In robotics, there are several applications that require the robot’s ability to recognize which movement the user wants to perform. For example, smart walking support systems, which help people with motor disabilities and the elderly while trying to walk or walk.

To create a system of classification of physical movements automatically, the main feature is the motion sensors. These sensors should be small and light and be in contact with the human body. Smartphones have several sensors on board, like two of the main ones used in this work, the accelerometer and the gyroscope. With the great growth of people using the mobile device, it is the ideal device to perform movement recognition.

• Android and Sensors API Android to develop the application that communicates with the sensors (Accelerometer and Gyroscope) of the smartphone to monitor the movements and collect the data.
• Firebase Database to store data collected by Android sensors.
• Jupyter Notebook to document the extraction of features and analysis of machine learning models.
• Python3 taking the data collection, the rest of the project was all developed in python.

The Python libraries below are required to run the project.

• Scikit-learn
• SciPy
• Numpy
• Matplotlib
• Pandas
• Flask

Run the following command to install:

$ pip install -U numpy scipy scikit-learn matplotlib pandas Flask

obs: The Anaconda distribution of python already has the above and most included packages.

This project has 4 applications.

• App-mobile: It collects the data according to the movement that the user has informed by a selector of movements, then it clicks to execute the application to begin to monitor the movements, and when the movement finishes, it stops clicking and the data is sent to the Firebase automatic. The application also implements a way to evaluate the machine learning model that has been trained. The user clicks run, makes the move. To see the answer, he clicks to stop when he finishes making the move. When Stop is clicked, the template will respond to what movement has been made. If it hits, the user marks as True Positive, if not, it marks as False Positive

  The figure on the left shows the data collection screen and the one on the right shows the evaluation screen for new entries.

• SRC/API: Api is a rest service that implements the trained model, and receives app evaluation data to classify a new entry.

  To run the API, navigate to the project folder and run the command below:

  $ python -m api

• SRC/Intra: The project below is responsible for preprocessing the raw data, and extracting raw data characteristics to assemble the training data set.

  To run the Intra project, navigate to the project folder and run the command below:

  $ python -m intra

• Notebooks: It documents the characteristics used and explains each one of them. It also documents any analysis of the chosen models to see which makes the best data modeling and which one performs best.

This basis demonstrates the process from data collection to the movement of a machine learning model.

1. The application sends the data collected from the sensors in json format to Firebase.

2. Data is saved in the Firebase Database service.

3. With data saved in the Firebase database, the application responsible for fetching and processing data online is executed.

4. The process receives the data in .json format and converts the file to .csv, and assembles a structure (The structure is described in detail in the notebook * Acquisition of characteristics *) in the file that will be used to extract the characteristics.

5. The Extraction process reads all the files containing the raw data and extracts the characteristics (The extraction of characteristics is described in detail in the * Characteristics * book) relevant to the movements, and creates the data set. After extraction, the data is written in .csv format and saved in the dataset folder.

6. To train the learning model, the dataset is loaded from the datasets folder.

7. The data is prepared before starting the training.

8. Train the machine learning model.

9. After the model is trained, the evaluation application sends the new data in json format to the classification service.

10. The service receives the data, and sends to process them and extract the characteristics.

11. The service receives the data, and sends to process them and extract the characteristics.

12. Predicts entry

13. Returns which movement was executed for the application.

This is the portable code of MRTOS for the Texas Instruments C28x platform. To use this
platform, please see the main mRTOS repository.

The portable code uses the following interrupts

• USER1, (interrupt #20, ISR_USER1), used for loading the first thread
• RTOSINT, (interrupt #16, ISR_RTOSINT), implemented as the context switcher
• INT14, (interrupt #14, ISR_CPUTIM2), CPUTIM2, used for generating system heartbeats

The portable code does not configure CPUTIM2. The configuration of CPUTIM2 must be
set before os_start(), and the timer must be disabled. When the operating
system starts, it will enable the timer automatically.

Do not use EINT and DINT instructions in the application. Use the nested
version provided by the operating system instead (os_enter_critical() and
os_exit_critical()). Be sure to replace the macros in TI’s peripheral library,
too, if it’s being used. Manipulating interrupts directly in the application can
really mess up the operating system’s shared variable access locks.

• FPU support
• Low power mode (when idle)
• Thread starts with interrupts enabled and EALLOW disabled

*: The interrupt priorities on the C28x core are hard-coded onto the silicon,
but the manual provides several ways to implement priorities in software.
The setting is recommended but not required. It is good enough to use
the hardware priorities but the interrupt latency might be slightly longer.

On modern microcontrollers, interrupt service routines uses a seperate stack.
On C2000, however, interrupts will use the stack of whichever process is currently
running. This increases the chances of a stack overflow. When allocating stack,
care must be taken to make sure the stack is sufficient for not only the current
thread context, but also for interrupts wherever current thread context is preempted.

// defined in rtos portable code
extern interrupt void ISR_RTOSINT(void);
extern interrupt void ISR_CPUTIM2(void);
extern interrupt void ISR_USER1(void);

// These variables are defined by the linker 
// as instructed by the linker command file
/* 
 * Example linker section:
 * 	.esysmem :> RAM, PAGE=0,
 *			LOAD_START(_esysmem_start),
 *			LOAD_SIZE(_esysmem_size)
 *
 * .esysmem is the "heap" section generated by
 * the compiler. Modify linker settings to 
 * change the size of this section.  
 */
extern int esysmem_start;
extern int esysmem_size;

int main(void)
{
    // initialize hardware, configure CPUTIM2 (do not enable it)
	
    // ...
	
    // Fill PIE vector table
    PIE_VECT_TABLE.RTOSINT = ISR_RTOSINT;
    PIE_VECT_TABLE.TINT2 = ISR_CPUTIM2;
    PIE_VECT_TABLE.USER1 = ISR_USER1;

    // enable PIE
    PIECTRL.PIECTRL.bit.ENPIE = 1;
    
    // initialize operating system
    os_config_t config;
    config.p_pool_mem = &esysmem_start;

	// suppress warning #70: "integer conversion results in truncation"
	// because we know that the size of the heap will be smaller than 
	// the maximum value of OSPORT_UINT_T. If you want to use a longer
	// OSPORT_UINT_T, that's fine.
	// WARNING: esysmem_size must be a multiple of OSPORT_MEM_ALIGN
#pragma diag_push
#pragma diag_suppress 70
    config.pool_size = (uintptr_t)(&esysmem_size);
#pragma diag_pop

    os_init(&config);
    
    // create some operating system objects here: threads, semaphores, etc.
    
    // ... 
    
    // start the operating system, run the first highest priority thread
    os_start();
    
    // reaches the point of no return. The execution should
    // never get here. If it does, something went wrong.
    
    for( ; ; )
   		;
    
    return 0;
}

• API
• Artificial Intelligence
• Awesome
• Books
• Career
• Competitive Programming
• CheatSheets
• Cloud
• Courses & Certifications
• Development
• Frameworks
• Front-End Development
• Back-End Development
• Git & GitHub
• Programming Languages
• Opportunities & Programs
• Projects
• Security
• Web Development Tools
• System Design
• Unix
• Web

CC0-1.0 License

Welcome to Bio-Sign Sentinel, where swarms of digital ants navigate the neon-lit corridors of data to solve complex routing problems. This project implements an Ant Colony Optimization (ACO) algorithm to tackle the Traveling Salesman Problem (TSP) with a cyberpunk twist.

In the neon-lit sprawl of our digital future, BioSign Sentinel emerges as a cutting-edge pathfinding daemon. Utilizing the bio-inspired Ant Colony Optimization (ACO) algorithm, this tool navigates the complex networks of Neo-Kyoto and Cyber-Detroit or (Neo-{insert your city}) with unparalleled efficiency.

In the sprawling megacities of tomorrow, where neon bleeds into the night and corporate AIs rule the datascape, your health is your most precious commodity. BioSign Sentinel isn’t just software – it’s your first line of defense against the viral threats lurking in the shadows of Neo-Kyoto and the back alleys of Cyber-Detroit.

This rapid symptom analysis daemon is designed to flag potential COVID-19 or COVID-32 infections before they compromise your system. Don’t trust the corp-sponsored clinics or back-alley ripperdocs – arm yourself with data and stay one step ahead of the pandemic.

1. ACOAlgorithm.cpp/.h: The neural network of our digital ants, implemented in C++ for blazing speed. The neural core of our digital ant swarm, coded in C++ for maximum processing speed.

2. Main.java: The command center GUI, bridging the gap between user and machine. The cyberspace interface, bridging wetware and software through a Java-based GUI.

3. visualize.py: Our augmented reality display, rendering optimized paths in vivid detail. Our augmented reality module, rendering optimized paths using Python’s matplotlib and networkx.

4. generate_data.py: The matrix architect, spawning vast cityscapes for our ants to explore. The virtual cityscape architect, generating vast datasets for our pathfinding swarms.

• Lightning-fast symptom analysis (fast performance)
• Cyberpunk-inspired GUI for immersive user experience (GUI Cyberpunk inspired)
• Secure, encrypted data transmission (Security was priority)
• Compatible with most cybernetic implants and bio-mods (Compatible with most PC and Laptops)

• Pheromone trail initialization
• Stochastic solution construction
• Pheromone update mechanism
• Local search optimization

• Time complexity: O(n^2 * m), where n is the number of cities and m is the number of ants
• Space complexity: O(n^2) for pheromone matrix storage

• α (alpha): pheromone influence factor
• β (beta): heuristic information influence factor
• ρ (rho): pheromone evaporation rate
• Q: pheromone deposit amount

Data Structures:

• Graph representation using adjacency matrix
• Priority queue for efficient city selection

• Real-time path rendering
• Pheromone intensity heat map
• Convergence analysis plots

• Clone the repo:
  git clone https://github.com/yourusername/BioSign-Sentinel.git
  cd BioSign-Sentinel

• Compile the C++ core:
  g++ -shared -fPIC -I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux ACOAlgorithm.cpp -o libACOAlgorithm.so

• Compile the Java interface:
  javac Main.java

• Generate a virtual cityscape:
  python generate_data.py

• Jack in and execute:
  java -Djava.library.path=. Main

• Load your generated city data and watch the digital swarm optimize in real-time.

BioSign Sentinel is a street-level diagnostic tool, not a replacement for professional medical wetware. Use at your own risk, runner.

• Download the BioSign Sentinel package from the darknet (Github on clearnet)
• Verify the digital signature to ensure no corp tampering (open-source security & licensing)
• Install using your cyberdeck’s package manager (Windows or Linux)
• Jack in and run the initialization sequence (launch and run exe with data)

• JDK 8+
• Python 3.x with matplotlib and networkx
• C++ compiler (g++ recommended)
• At least 2GB of dedicated cyberdeck memory (computer memory)
• CUDA-compatible GPU for parallel processing (optional)

Feel the pulse of the code? Want to enhance our digital ecosystem? Pull requests are welcome. For major upgrades, open an issue first to discuss what you’d like to change.

This project is licensed under the MIT License – see the LICENSE.md file for details.

• The ghosts in the machine
• The neon-lit streets of our imaginations
• Caffeine. Lots of caffeine.

Remember, in this chrome jungle, information is power. Stay informed, stay alive.

PGN Reader is a user-friendly and efficient application that allows you to read .pgn files smoothly through a terminal. The application is incredibly fast and lightweight, which means it can work on almost any device or system. It supports Chess 960 and can handle variations, comments, and annotations with clean and readable formatting. PGN Reader provides a simple way to access all the necessary information from your .pgn files.

PGN reader consists of:

• README.md > File explaning everything about the application
• LICENSE > License under which the program must be used
• EXAMPLE.png > Screenshot of a terminal while viewing a game in PGN Reader
• example.pgn > Annotated PGN file containing The Game Of The Century
• src > Directory with source code of the application

Using and compiling PGN Reader is as easy as it gets. Download the entire project and then compile the source code.
NOTE: you have to compile all .c files, not only main.c

  gcc -o pgn-reader ./src/*.c

After the program is compiled, view .pgn file as follows

  <executable> <path to .pgn file>
  ./pgn-reader ./example.pgn

A: It’s a file extension specifically used for saving chess games. More information on wikipedia

A: The quickest way is to use lichess and import a game to their site (you can get a computer analysis for free too). Then, in an analysis tab, you can export your game as a .pgn.

A: If ever an alien civilization destroys all network infrastructure and asks you to present them The Game of the Century within a few milliseconds, or otherwise they will destroy everything you know and love, only then will your gratitude be immeasurable.

This is a personal portfolio website built using React, Tailwind CSS, Vite, React Router DOM, Framer Motion, React Icons, React Tilt, React Intersection Observer, email.js, and Sanity backend.

The website consists of five main sections: Hero, Service/About, Skills, Projects, and Contact.

• React: A popular JavaScript library for building user interfaces.
• Tailwind CSS: A utility-first CSS framework for rapidly styling your application.
• Vite: A fast build tool for modern web development.
• React Router DOM: A routing library for React applications.
• Framer Motion: A production-ready motion library for React.
• React Icons: A collection of icons for React applications.
• React Tilt: A lightweight 3D parallax tilt effect library for React.
• React Intersection Observer: A wrapper around the Intersection Observer API for React.
• email.js: A service for sending emails directly from JavaScript.

• The public directory contains static files such as favicon and _redirects file.
• The src directory contains the main source code for the portfolio website.
• The components directory contains reusable components and sections of the website.
• The pages directory contains individual pages of the website.
• App.js is the entry point of the application.
• index.js is the main JavaScript file that renders the application.
• .gitignore specifies files and directories that should be ignored by Git.
• package.json contains information about the project and its dependencies.
• README.md (the file you are currently reading) provides information about the project.

If you’d like to contribute to this project, please follow these guidelines:

1. Fork the repository on GitHub.
2. Create a new branch for your feature or bug fix.
3. Make your changes and commit them.
4. Push your changes to the branch.

If you have any questions or suggestions, feel free to reach out to me:

Name: Pritam Ghosh

Email: pritamattwork@gmail.com

Portfolio: https://pritam-ghosh.netlify.app/

This project is an easy-to-use fullstack Online Invoicing application for creating and Sending invoices to customers, suiteable for Startups, Business Owners and Freelancers.

-Add Customers or clients.

• Create a new invoice
• Compose and quote invoice.
• Send invoice to customer
• Download invoice as PDF. -Record Payment

• You firstly add a customer you would want to send an invoice to. Create an invoice to send to the customer. Add the billing information, item description, amount, quantity and discount if any.

You can also add more items, edit or delete item from your invoice. By clicking on the Send Invoice button, you can send invoice via email to the customer. You can also download the invoice as PDF.

Landing page display.

Dashboard View

Sample Invoice Display:

Create An Invoice:

• Getting Started
  • Tools Required
  • Installation
• Development
• Running the App
• Deployment
• Authors
• License

The project is built with;

• React JS -Library for building user interfaces
• React Bootstrap – The most popular front-end framework for building React application.
• CSS

It uses Node.js >= 12.18.3

Ensure you have NodeJS installed by entering node -v on your terminal If you don’t have NodeJS installed, go to the NodeJS Website, and follow the download instructions

The following tools are required to run this application:

• A text editor like Visual Studio Code
• Command Line

You can clone the repository directly using this command: git clone https://github.com/jamesoyanna/smart-invoice-landing-page.git

Installation steps:

Node.js and Yarn or Npm Your computer must have installed nodejs, and yarn to run this application You can download Node.js from https://nodejs.org and yarn from https://yarnpkg.com/lang/en/docs/install/ . NPM comes bundled with Node.js

After clonning the application, You will have to install all the dependencies and packages. You can do this by running yarn or npm install from the root of the project folder to install.

Run yarn start or npm stall from the root of your project to start a dev server. 
Navigate to http://localhost:3000/. 
The app will automatically reload if you make changes to any of the source files.

• GitHub
• LinkedIn

A Dark theme for the PiHole admin page. (Now FTL compatible)

1. open a terminal (or SSH if you’re remoting in) ( Ctrl + Alt + T )
2. Type: cd /var/www/html/
3. Type: sudo wget https://raw.githubusercontent.com/lkd70/PiHole-Dark/master/install.sh
4. Type: sudo chmod +x install.sh
5. Type: sudo ./install.sh
6. Follow the onscreen instructions!

Not a fan of the style? Sorry to hear, please feel free to leave some feedback on the Official Thread. Sadly this theme isn’t for everyone, so here’s a simple method to restore the origional beauty of PiHole:

1. open a terminal (or SSH if you’re remoting in) ( Ctrl + Alt + T )
2. Type: cd /var/www/html/admin/
3. Type git reset --hard
4. Go leave some feedback so we know what you didn’t like!

Something you’d like to see? Or maybe there’s an incompatibility with a newer version of pi-hole? Please open an issue or make a pull request!

First of all, I’d like to say sorry for your eyes, I’m sure they hurt the way mine did upon first seeing that sight.
Let’s look at two possible solutions to this.

You can easily replace the ugly image in /var/www/html/admin/img/boxed-bg.jpg with a pretty dark one.

You can change to a wide-view from the admin website by navigating to: Settings -> API / Web Interface -> Web interface settings and un-checking the Use boxed layout option.

Refunds cost $1 each, please contact me at totallylegitemail@contact.com

(Have you tried refreshing your browsers cache? Chances are it’s still grabbing the old files)

All credits to the original creators of these files, I am merely an editor.
All credits to the Pi-Hole Team for their great platform.

Do follow the individual licenses of these files as supplied by the authors.

Inspired by this thread.

Thanks to deathbybandaid for the new easy install method!

Graphsurge is a new system for performing analytical computations on multiple snapshots or views of large-scale static property graphs. Graphsurge allows users to create view collections, a set of related views of a graph created by applying filter predicates on node and edge properties, and run analytical computations on all the views of a collection efficiently.

Graphsurge is built on top of Timely Dataflow and Differential Dataflow, which provides two huge benefits:

• Differential Dataflow can incrementally maintain the results for any general computation, including cyclic or iterative computations (which include many graph algorithms such as Connected Components. Analytical computations in Graphsurge are expressed using Differential operators and enables reusing computation results across the views of a collection instead of running computations from scratch on each view. This results in huge savings on the total runtime.
• We use the Timely execution engine to seamlessly scale both the materialization of view collections and running analytical computations to a distributed environment, similar to using other execution frameworks such as Spark or Flink.

Graphsurge stores view collections using a form of delta encoding, where the data for a view GV_i represent its difference with the previous view GV_i-1. This representation can also be directly used as inputs to Differential Dataflow computations.

In general, the runtime of a black-box differential computation (such as the user-defined computations in Graphsurge) is correlated with the total number of diffs of a view collection. Graphsurge enables 2 key optimizations based on this observation:

• Collection Ordering: The total number of diffs of a view collection depends on the order the views (similar views placed next to each other will generate less diffs) and we want to reorder a given set of views to get the lowest number of diffs. This Collection Ordering Problem is related to the Consecutive Block Minimization Problem, which is NP-Hard! Graphsurge solves this problem using a constant-factor approximation algorithm (resulting in up to 10x less diffs in our experiments).

• Adaptive Collection Splitting: Maintaining computation results unsurprisingly implies an overhead for Differential Dataflow, as it needs to check the entire history of a key to determine the effect of a new update. This overhead is especially large for cases where the number of diffs of a view are high, or for computations (like PageRank) which results in a large number of output changes even for small number of input updates. In such cases, it is faster to run the computation on a view from scratch instead of trying to reuse results from previous views.

  Graphsurge keeps track of the correlation between the number of the diffs and the actual computation time when running differentially and also when rerunning from scratch. It uses a linear regression model to adaptively decide at runtime to split the view collection at the point where rerunning from scratch is predicted to be faster than to continue running differentially.

More details on our techniques and experimental results can be found in our paper.

Graphsurge is written in Rust. To run the Graphsurge cli, download and build the binary:

$ git clone https://github.com/dsg-uwaterloo/graphsurge && cd graphsurge
$ cargo build --release
$ ./target/bin/graphsurge

graphsurge> SET THREADS 4 AND PROCESS_ID 0;

graphsurge> LOAD GRAPH WITH
    VERTICES FROM 'data/small_properties/vertices.txt' and
    EDGES FROM 'data/small_properties/edges.txt'
    COMMENT '#';

graphsurge> CREATE VIEW COLLECTION Years WHERE
    [year <= 2000 and u.country = 'canada' and v.country = 'canada'],
    [year <= 2005 and u.country = 'canada' and v.country = 'canada'],
    [year <= 2010 and u.country = 'canada' and v.country = 'canada'];

$ mkdir bfs_results

graphsurge> RUN COMPUTATION wcc ON COLLECTION Years SAVE RESULTS TO 'bfs_results';

To run Graphsurge on multiple machines, say on 2 hosts server1 and server2, start Graphsurge and set the process ids:

# On server1
graphsurge> SET THREADS 32 AND PROCESS_ID 0;

# On server2
graphsurge> SET THREADS 32 AND PROCESS_ID 1;

Then run the same queries on both of them. Make sure that server1 and server2 can access each other at the specified port.

graphsurge> LOAD GRAPH WITH
    VERTICES FROM 'data/small_properties/vertices.txt' and
    EDGES FROM 'data/small_properties/edges.txt'
    COMMENT '#';
graphsurge> CREATE VIEW COLLECTION Years WHERE
    [year <= 2000 and u.country = 'canada' and v.country = 'canada'],
    [year <= 2005 and u.country = 'canada' and v.country = 'canada'],
    [year <= 2010 and u.country = 'canada' and v.country = 'canada']
    HOSTS 'server1:9000' 'server2:9000';
graphsurge> RUN ARRANGED_DIFFERENTIAL COMPUTATION wcc on COLLECTION Years
    HOSTS 'server1:9000' 'server2:9000';

The same process can be repeated for additional hosts machines.

Graphsurge already has implementations for a set of common graph algorithms. New computations can be written using the Analytics Computation API. You can see examples of how to use the API for bfs and scc.

Check the experiments folder for examples on how to use Graphsurge.