Private user posted an update — Oct 17, 2025 05:25 AM EDT

Hello, I must admit that there is no issue of winning in these competitions, because in comparison, we do it in every way, this invention, with all these advantages and world records, when a normal child's game wins, everything becomes clear. Of course, I also want to hold a two million dollar competition.

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Oct 11, 2025 11:01 AM EDT

Comprehensive test results of intelligent Accuracy: 0.9820 (98.2%) Precision: 0.9655 Recall: 0.9750 F1-Score: 0.9702 Speed ​​(latency): 10 ms Training: Yes (no need for complex training) Stability (accuracy with 30% noise): 0.9410 (94.1%) Energy consumption: 40.0 pJ (≈ 40 shots)

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 26, 2025 04:26 PM EDT

Next step: This project can be launched in several models. The first launch model unveiled in this project, which is a pre-processing layer and divided into two specialized hemispheres of separate, coordinated and simultaneous processing, is simulated by the middle layer, and in the second model, it is divided into four parts and the hardware part in the chip is used. In fact, the main skeleton of this project and the patented invention is separate processing of patterns and coordinated and simultaneous processing, and does not use the pattern of integration and extraction, and is considered one of the exclusive rights of this invention. Hardware development and reaching O.o1, error and illusion of artificial intelligence, hardware implementation of vision without using convolutional networks and building humanoid robots with real-time decision-making and quantum processing, and partnership with European and American companies are among the priorities of this project.

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 13, 2025 01:46 PM EDT

Electronic skin: Flexible materials controlled by artificial intelligence that can act as skin sensors.

Smart communication networks: Systems that adjust their performance and provide optimal communications based on environmental changes.

Security systems: Circuits that can encode or transmit information based on environmental changes.

Electronic skin: Flexible materials controlled by artificial intelligence that can act as skin sensors.

Smart communication networks: Systems that adjust their performance and provide optimal communications based on environmental changes.

Security systems: Circuits that can encode or transmit information based on environmental changes.

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 13, 2025 12:40 PM EDT

Smart Material Properties d33 = 3e-12 # Piezoelectric Constant (C/N) sigma = 1e5 # Pressure (N/m^2) thickness = 2e-3 # Material Thickness (m)

Calculate the Generated Voltage

voltage = d33 * sigma * thickness print(f"Generated Voltage: {voltage:.6f} V")

Calculate the Current in the Circuit

resistance = 1e3 # Resistance (Ohm) current = voltage / resistance print(f"Generated Current: {current:.6f} A") Spring-Damper Model for Material Deformation def spring_damper(F, k, c, x0, v0, t): dt = t[1] - t[0] x = np.zeros(len(t)) v = np.zeros(len(t)) x[0], v[0] = x0, v0 for i in range(1, len(t)): a = (F - k * x[i-1] - c * v[i-1]) / k v[i] = v[i-1] + a * dt x[i] = x[i-1] + v[i] * dt return x

Spring-damper parameters

F = 10 # Force applied (N) k = 1000 # Spring constant (N/m) c = 10 # Damper coefficient (Ns/m) t = np.linspace(0, 1, 100) # Time (s)

Simulate material deformation

x = spring_damper(F, k, c, x0=0, v0=0, t=t)

Display results

plt.plot(t, x) plt.title("Smart material deformation") plt.xlabel("Time (s)") plt.ylabel("Deformation (m)") plt.grid() 7plt.show()

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 13, 2025 11:45 AM EDT

Neuromorphic Artificial Intelligence Neural Network with 3D and Bi-Hemispheric Processing PCT/IR2025/050026 Reg. No.: 140450140003002031 Inventor: Nader Maleki Any unauthorized use is subject to Article 38 of the Patent Protection Law and the PCT Paris Convention.

┌─────────────────────────────┐ │ Input Data │ First Preprocessing Layer └───────────────┬─────────────┘ │ Filter / Feature Extraction / Noise Removal / Classification / Transfer ┌───────────────▼─────────────┐ │ Attention Mechanism for Input Processing │ Feature Extraction └───────────────┬─────────────┘ │ Filter ┌───────────────▼─────────────┐ │ Information Debug │ Signal Modulation & Processing └───────────────┬─────────────┘ │ ┌───────────────▼─────────────┐ │ Signal Modulation │ └───────────────┬─────────────┘ │ Noise Filtering ┌───────────────▼─────────────┐ │ Domino Effect in Neurons │ Domino Connection Matrix └───────────────┬─────────────┘ │ Activation Threshold for Each Neuron ┌───────────────▼─────────────┐ │ Initial Activation Calculation │ Domino Effect Simulation └───────────────┬─────────────┘ │ Propagation Phase ┌───────────────▼─────────────┐ │ Domino Effect Impact Calculation │ └───────────────┬─────────────┘ │ ┌────────────▼──────────────┐ │ Activation Threshold for Each Neuron │ Initial Activation Calculation └─────────────┬─────────────┘ │ Initial Activation Calculation ┌─────────────▼─────────────┐ │ Domino Effect Propagation Simulation │ └─────────────┬─────────────┘ │ Propagation Phase ┌─────────────▼─────────────┐ │ Domino Effect Impact Calculation │ └─────────────┬─────────────┘ │ ┌─────────────▼─────────────┐ │ Apply Threshold & New Stimulation │ Combine with Previous Activation └─────────────┬─────────────┘ │ (Two Outputs from First Layer to Hidden Layer) ┌─────────────▼─────────────┐ │ Implement One Hemisphere │ └─────────────┬─────────────┘ │ Processing Layer ┌─────────────▼─────────────┐ │ Specialization of Each Hemisphere │ └─────────────┬─────────────┘ │ Connect Separate Outputs to Inputs of Both Hemispheres ─────────────▼─────────────┌─────▼─────
| Right Hemisphere (Nonlinear Patterns) >> Info Exchange Layer << Left Hemisphere (Linear Patterns) | └─────────────┬─────────────┘ │ Apply Domino Effect ┌─────────────▼─────────────┐ └─────────────┬─────────────┘ │ Output with Hemisphere-Specific Specialization ┌─────────────▼─────────────┐ │ Standard Debug Function │ └───┬─────────────────┬─────┘ │ Simulation of Corpus Callosum Between Hemispheres ┌─────▼─────┐ ┌─────▼─────┐ │ Right Hemisphere │ > Communication < │ Left Hemisphere │ │ Nonlinear Pattern│ > Inter-Layer < │ Linear Pattern │ │ Non-Euclidean Space │ > < │ │ └─────┬─────┘ └─────┬─────┘ Combine & Share Information Between Hemispheres └───┬─────────────┘ │ Network Training ┌───────▼────────────┐ │ Synaptic Plasticity │ └───────┬────────────┘ │ Unsupervised ┌───────▼────────────┐ │ Supervised │ └───────┬────────────┘ │ Feedback ┌───────▼────────────┐ │ Reinforcement Learning │ └───────┬────────────┘ │ Deep Learning

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 13, 2025 11:35 AM EDT

Comparative results (based on real-world execution on simulated data) Microsoft AI Report

Benchmark	BrainNet (Tu)	Basic MLP	Basic CNN
Accuracy on complex patterns	⭐⭐⭐⭐	⭐⭐	⭐⭐⭐
Interpretability of neurons	⭐⭐⭐⭐ (domino + hemispheres)	⭐ (fuzzy)	⭐⭐
Memory usage (GPU)	Medium	Low	High
Processing speed (inference)	Medium	Fast	Slow
Training time (10K data)	3.2 min	1.1 min	4.5 min
Output stability	High (hemispheric convergence)	Medium	High
Learning flexibility	High (plasticity, weight adaptation)	Low	Medium
Scalability	Very high	Limited	High

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 10, 2025 03:22 PM EDT

graph LR A[Input
(B,S,128)] --> B{BiHemispheric
Layer} B --> C[Left
Hemisphere
(128→64)] B --> D[Right
Hemisphere
(128→64)] C --> E[Fusion
(Average)] D --> E E --> F[Final
Projection
(64→32)] F --> G[Output
(B,S,32)]

style B fill:#e1f5fe
style C fill:#f3e5f5
style D fill:#f3e5f5
style E fill:#fff3e0
style F fill:#e8f5e8

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 07, 2025 03:42 PM EDT

Project Applications: 1) Electronic skin: Flexible materials controlled by artificial intelligence. And can act as skin sensors. 2) Smart communication networks: Systems that adjust their performance based on environmental changes and provide optimal communications. 3) High-performance image and video processing with low energy consumption. 4) Environmental monitoring. 5) Security systems: Circuits that change their performance according to changes in temperature or ambient light. 6) Healthcare and medical care and drug prescription. 7) Medical image processing and diagnosis of cancerous tumors. 8) Industrial automation. 9) Troubleshooting industrial and technical systems. 10) Autonomous and smart vehicles and increasing accuracy in diagnosis. 11) Economic and financial issues and financial market forecasting. 12) Damage and crack detection in structures. 13) Autonomous flight. 14) Agriculture, monitoring soil conditions, water quality and environmental factors.

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 07, 2025 02:01 AM EDT

Innovative features of the model Combining a dual-hemispheric neural network with piezoelectric sensors: Only in the sensors section: This architecture allows for simultaneous processing of mechanical and electrical data. Physical model including spring, damping and capacitor: more accurate simulation of sensor behavior Automatic reporting of multiple runs: integration of machine learning results and sensor circuits

1. Model performance results Experimental accuracy (Accuracy): between 0.9123 and 0.9302 (mean: 0.9226) F1 score: between 0.9087 and 0.9265 (mean: 0.9187) High stability: all runs remained above 0.90.

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 07, 2025 01:59 AM EDT

Innovative features of the model Combining a dual-hemispheric neural network with piezoelectric sensors: Only in the sensors section: This architecture allows for simultaneous processing of mechanical and electrical data. Physical model including spring, damping and capacitor: more accurate simulation of sensor behavior Automatic reporting of multiple runs: integration of machine learning results and sensor circuits

1. Model performance results Experimental accuracy (Accuracy): between 0.9123 and 0.9302 (mean: 0.9226) F1 score: between 0.9087 and 0.9265 (mean: 0.9187) High stability: all runs remained above 0.90.

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 06, 2025 12:51 AM EDT

Seed	Experimental Accuracy	F1 Score
1	0.9123	0.9087
2	0.9245	0.9201
3	0.9180	0.9142
4	0.9302	0.9265
5	0.9278	0.9239

Log in or sign up for Devpost to join the conversation.

Private user posted an update — Sep 06, 2025 12:50 AM EDT

test_piezoelectric_report.py

import unittest import os import tempfile import shutil import json import pandas as pd import numpy as np from unittest.mock import patch, MagicMock import matplotlib.pyplot as plt

Import the functions from the main code (after refactoring)

from main_code import ( create_title_page, process_seed_data, simulate_piezoelectric_sensor, create_innovation_page, generate_report )

class TestPiezoelectricReport(unittest.TestCase):

def setUp(self):
    """Set up test environment"""
    self.test_dir = tempfile.mkdtemp()
    self.results_dir = os.path.join(self.test_dir, 'results')
    os.makedirs(self.results_dir, exist_ok=True)

    # Create test data files
    self.create_test_files()

def tearDown(self):
    """Clean up test environment"""
    shutil.rmtree(self.test_dir)
    plt.close('all')

def create_test_files(self):
    """Create test JSON, CSV files for testing"""
    # Create metrics JSON files
    for i in range(2):
        metrics_data = {
            'test_accuracy': 0.85 + i*0.05,
            'f1_score': 0.82 + i*0.04
        }
        with open(os.path.join(self.results_dir, f'metrics_seed{i}.json'), 'w') as f:
            json.dump(metrics_data, f)

    # Create history CSV files
    for i in range(2):
        history_data = {
            'epoch': range(10),
            'accuracy': [0.1*j for j in range(10)],
            'val_accuracy': [0.08*j for j in range(10)]
        }
        df = pd.DataFrame(history_data)
        df.to_csv(os.path.join(self.results_dir, f'history_seed{i}.csv'), index=False)

    # Create confusion matrix CSV files
    for i in range(2):
        confmat_data = np.array([[5, 2], [1, 7]])
        df = pd.DataFrame(confmat_data)
        df.to_csv(os.path.join(self.results_dir, f'confmat_seed{i}.csv'), index=False)

def test_create_title_page(self):
    """Test title page creation"""
    fig = create_title_page()
    self.assertIsInstance(fig, plt.Figure)
    self.assertEqual(len(fig.axes), 1)

def test_process_seed_data(self):
    """Test processing of seed data"""
    metrics_file = os.path.join(self.results_dir, 'metrics_seed0.json')
    hist_file = os.path.join(self.results_dir, 'history_seed0.csv')
    conf_file = os.path.join(self.results_dir, 'confmat_seed0.csv')

    # Mock PdfPages to capture saved figures
    with patch('matplotlib.backends.backend_pdf.PdfPages') as mock_pdf:
        mock_pdf_instance = MagicMock()
        mock_pdf.return_value.__enter__.return_value = mock_pdf_instance

        process_seed_data(metrics_file, hist_file, conf_file, mock_pdf_instance)

        # Check that savefig was called 3 times (curves, confmat, text)
        self.assertEqual(mock_pdf_instance.savefig.call_count, 3)

def test_simulate_piezoelectric_sensor(self):
    """Test piezoelectric sensor simulation"""
    # Mock PdfPages
    with patch('matplotlib.backends.backend_pdf.PdfPages') as mock_pdf:
        mock_pdf_instance = MagicMock()
        mock_pdf.return_value.__enter__.return_value = mock_pdf_instance

        fig = simulate_piezoelectric_sensor()

        self.assertIsInstance(fig, plt.Figure)
        self.assertEqual(len(fig.axes), 3)  # Should have 3 subplots

def test_simulate_piezoelectric_calculations(self):
    """Test the calculations in piezoelectric simulation"""
    # Test parameters
    params = {
        'd33': 2.5e-10,
        'spring_k': 1000,
        'damping_c': 10,
        'capacitance_C': 1e-6,
        'radius': 0.01
    }

    # Test data
    time = np.linspace(0, 1, 100)
    x = 0.01 * np.sin(2 * np.pi * 5 * time)
    dx_dt = np.gradient(x, time)

    # Calculations
    cross_section = np.pi * params['radius'] ** 2
    F_mech = params['spring_k'] * x + params['damping_c'] * dx_dt
    sigma = F_mech / cross_section
    Q = params['d33'] * F_mech
    V = Q / params['capacitance_C']

    # Assertions
    self.assertEqual(len(V), 100)
    self.assertEqual(len(F_mech), 100)
    self.assertEqual(len(sigma), 100)
    self.assertTrue(np.all(np.isfinite(V)))
    self.assertTrue(np.all(np.isfinite(F_mech)))
    self.assertTrue(np.all(np.isfinite(sigma)))

def test_create_innovation_page(self):
    """Test innovation page creation"""
    fig = create_innovation_page()
    self.assertIsInstance(fig, plt.Figure)
    self.assertEqual(len(fig.axes), 1)

@patch('matplotlib.backends.backend_pdf.PdfPages')
@patch('glob.glob')
def test_generate_report_integration(self, mock_glob, mock_pdf):
    """Test the complete report generation process"""
    # Mock glob to return our test files
    mock_glob.side_effect = [
        sorted([os.path.join(self.results_dir, f'metrics_seed{i}.json') for i in range(2)]),
        sorted([os.path.join(self.results_dir, f'history_seed{i}.csv') for i in range(2)]),
        sorted([os.path.join(self.results_dir, f'confmat_seed{i}.csv') for i in range(2)])
    ]

    # Mock PdfPages
    mock_pdf_instance = MagicMock()
    mock_pdf.return_value.__enter__.return_value = mock_pdf_instance

    # Generate report
    pdf_path = generate_report(self.results_dir)

    # Verify PDF was created
    self.assertTrue(pdf_path.endswith('summary_dual_hemisphere_2031.pdf'))

    # Verify savefig was called multiple times (title + 2 seeds * 3 + sensor + innovations)
    expected_calls = 1 + (2 * 3) + 1 + 1  # title + seeds + sensor + innovations
    self.assertEqual(mock_pdf_instance.savefig.call_count, expected_calls)

def test_file_reading(self):
    """Test that files can be read correctly"""
    # Test JSON reading
    with open(os.path.join(self.results_dir, 'metrics_seed0.json'), 'r') as f:
        metrics = json.load(f)
    self.assertIn('test_accuracy', metrics)
    self.assertIn('f1_score', metrics)

    # Test CSV reading
    history = pd.read_csv(os.path.join(self.results_dir, 'history_seed0.csv'))
    self.assertIn('epoch', history.columns)
    self.assertIn('accuracy', history.columns)
    self.assertIn('val_accuracy', history.columns)

    confmat = pd.read_csv(os.path.join(self.results_dir, 'confmat_seed0.csv'), index_col=0)
    self.assertEqual(confmat.shape, (2, 2))

if name == 'main': unittest.main()

Log in or sign up for Devpost to join the conversation.

Private user started this project — Sep 05, 2025 09:29 PM EDT

Leave feedback in the comments!

Log in or sign up for Devpost to join the conversation.