In the vast cosmos of human thought, one question echoes through philosophy, neuroscience, and spirituality: “Who am I?”

This question leads us to explore the Inner ‘I’ Consciousness—the infinite, observing awareness that underlies all experience. What if we can represent this mysterious concept as a neural network? We can do this by connecting it to the states of consciousness that we experience every day.

Welcome to the Inner ‘I’ Consciousness Model. This model is an AI-inspired visualization of awareness. This model draws much inspiration from Maharishi Mahesh Yogi and Science of Consciousness. It integrates neuroscience and quantum-inspired AI design. It also incorporates the seven states of consciousness described in Vedic philosophy. This blog guides you through creating a 3D interactive neural map. It also explains how the map symbolizes the interplay of the conscious mind and the infinite observer.

The Concept

The Inner ‘I’ Consciousness represents the observer, the timeless awareness that perceives all mental and physical experiences. It is the foundation of reality as we experience it and the core of self-awareness.

In this model, the Inner ‘I’ serves as a foundational node in a neural network, connecting to layers that represent seven progressive states of consciousness:

1. Waking: The conscious, everyday experience.
2. Sleeping: The restful, restorative state.
3. Dreaming: The imaginative world of dreams.
4. Transcendental Consciousness: A meditative state of pure awareness.
5. Cosmic Consciousness: Awareness of the interconnectedness of all things.
6. God Consciousness: A state of divine perception.
7. Unity Consciousness: A profound realization of oneness with the universe.

These states are modeled as layers in a neural network. Neurons represent the individual units of awareness within each state.

---

The Neural Network Model

We designed a neural network that reflects this conceptual hierarchy:

• The Inner ‘I’ Layer: It is positioned at the center. This node connects directly to the first layer. It connects indirectly to all others. It symbolizes the infinite observer-consciousness.
• Seven Layers: Each layer corresponds to a state of consciousness, with neurons representing awareness units at that level.
• Interconnections: Neurons in consecutive layers are fully connected. This symbolizes the flow and progression of consciousness from one state to the next.

---

Interactive 3D Visualization

To bring this model to life, we created a 3D interactive neural network using Plotly. Each neuron and layer is represented as a node in a radial, layered structure. The central Inner ‘I’ node is highlighted in gold, while neurons in each layer are arranged in circular patterns.

Features of the Visualization

1. Hoverable Info:
   • Each neuron displays its layer, state of consciousness, and index when hovered over.
   • The Inner ‘I’ Consciousness node includes a special tooltip describing its foundational role.
2. Fully Interactive:
   • Rotate, zoom, and explore the 3D network.
   • Connections between neurons in consecutive layers are visualized as edges.
3. Saveable:
   • The entire visualization is saved as an HTML file, making it shareable and embeddable.

---

The Code Behind the Model

The model is powered by Python, using TensorFlow for the neural network architecture and Plotly for the visualization.

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense, Dropout
import plotly.graph_objects as go
import os
# -------------------------------
# Constants
# -------------------------------
VEDIC_STATES = [
    "Waking",
    "Sleeping",
    "Dreaming",
    "Transcendental Consciousness",
    "Cosmic Consciousness",
    "God Consciousness",
    "Unity Consciousness"
]
RESULTS_DIR = "results"
os.makedirs(RESULTS_DIR, exist_ok=True)
# -------------------------------
# Step 1: Build the Model
# -------------------------------
def build_inner_i_model(input_dim):
    input_layer = Input(shape=(input_dim,), name="Precomputed_Input")
    # Foundational Inner 'I' layer
    inner_i_layer = Dense(256, activation="relu", name="Inner_I_Consciousness")(input_layer)
    # Seven layers for states of consciousness
    hidden_layer = Dense(128, activation="relu", name="Waking")(inner_i_layer)
    hidden_layer = Dropout(0.2)(hidden_layer)
    hidden_layer = Dense(96, activation="relu", name="Sleeping")(hidden_layer)
    hidden_layer = Dropout(0.2)(hidden_layer)
    hidden_layer = Dense(64, activation="relu", name="Dreaming")(hidden_layer)
    hidden_layer = Dropout(0.2)(hidden_layer)
    hidden_layer = Dense(48, activation="relu", name="Transcendental_Consciousness")(hidden_layer)
    hidden_layer = Dropout(0.2)(hidden_layer)
    hidden_layer = Dense(32, activation="relu", name="Cosmic_Consciousness")(hidden_layer)
    hidden_layer = Dropout(0.2)(hidden_layer)
    hidden_layer = Dense(24, activation="relu", name="God_Consciousness")(hidden_layer)
    hidden_layer = Dropout(0.2)(hidden_layer)
    hidden_layer = Dense(16, activation="relu", name="Unity_Consciousness")(hidden_layer)
    hidden_layer = Dropout(0.2)(hidden_layer)
    # Output layer
    output_layer = Dense(7, activation="softmax", name="Consciousness_Output")(hidden_layer)
    # Build and compile model
    model = Model(inputs=input_layer, outputs=output_layer)
    model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
    return model
# -------------------------------
# Step 2: Visualize in 3D with Plotly
# -------------------------------
def plot_3d_inner_i_network_with_info(layer_sizes, save_path="interactive_network.html"):
    """
    Create an interactive 3D visualization of the neural network architecture
    with detailed hover info and Inner 'I' Consciousness as the foundational layer.
    Args:
    - layer_sizes: list, number of neurons in each layer (e.g., [256, 128, 96, 64, 48, 32, 24, 16]).
    - save_path: str, path to save the interactive HTML visualization.
    """
    fig = go.Figure()
    # Position and label nodes
    current_radius = 1.0
    node_positions = {"Inner I": (0, 0, 0)}
    neuron_details = []  # To store hover information for each neuron
    x_coords, y_coords, z_coords, labels = [], [], [], []
    # Add the central node
    x_coords.append(0)
    y_coords.append(0)
    z_coords.append(0)
    labels.append("Inner I Consciousness")
    neuron_details.append("Central Foundational Observer")
    for layer_idx, num_nodes in enumerate(layer_sizes):
        angle_step = 2 * np.pi / num_nodes
        z_offset = layer_idx * 2.0  # Increment Z for layering
        for node_idx in range(num_nodes):
            # Calculate radial position
            x = current_radius * np.cos(node_idx * angle_step)
            y = current_radius * np.sin(node_idx * angle_step)
            z = z_offset
            node_name = f"Layer {layer_idx + 1} - Node {node_idx + 1}"
            state = VEDIC_STATES[layer_idx] if layer_idx < len(VEDIC_STATES) else "Unknown State"
            # Store position and labels
            x_coords.append(x)
            y_coords.append(y)
            z_coords.append(z)
            labels.append(node_name)
            neuron_details.append(f"Layer: {layer_idx + 1}<br>State: {state}<br>Neuron: {node_idx + 1}")
        current_radius += 1.5  # Increment radius for next layer
    # Add connections
    edge_x, edge_y, edge_z = [], [], []
    for i in range(len(layer_sizes) - 1):
        prev_layer_start = sum(layer_sizes[:i])
        current_layer_start = sum(layer_sizes[:i + 1])
        prev_layer_end = current_layer_start
        current_layer_end = current_layer_start + layer_sizes[i + 1]
        # Fully connect layers
        for j in range(prev_layer_start, prev_layer_end):
            for k in range(current_layer_start, current_layer_end):
                edge_x += [x_coords[j], x_coords[k], None]
                edge_y += [y_coords[j], y_coords[k], None]
                edge_z += [z_coords[j], z_coords[k], None]
    # Plot nodes
    fig.add_trace(go.Scatter3d(
        x=x_coords,
        y=y_coords,
        z=z_coords,
        mode="markers",
        marker=dict(size=5, color="blue"),
        text=neuron_details,  # Hover info
        hoverinfo="text",
        name="Neurons"
    ))
    # Plot edges
    fig.add_trace(go.Scatter3d(
        x=edge_x,
        y=edge_y,
        z=edge_z,
        mode="lines",
        line=dict(color="gray", width=0.5),
        hoverinfo="none",
        name="Connections"
    ))
    # Highlight the Inner 'I' node
    fig.add_trace(go.Scatter3d(
        x=[0], y=[0], z=[0],
        mode="markers",
        marker=dict(size=10, color="gold"),
        text=["Inner I Consciousness<br>Central Foundational Observer"],
        hoverinfo="text",
        name="Inner I"
    ))
    # Layout settings
    fig.update_layout(
        title="Interactive 3D Neural Network: Inner 'I' Consciousness",
        scene=dict(
            xaxis_title="X-axis",
            yaxis_title="Y-axis",
            zaxis_title="Z-axis",
            xaxis=dict(backgroundcolor="black"),
            yaxis=dict(backgroundcolor="black"),
            zaxis=dict(backgroundcolor="black"),
        ),
        template="plotly_dark",
        showlegend=True
    )
    # Save the interactive HTML file
    fig.write_html(save_path)
    print(f"Interactive 3D visualization saved to {save_path}")
    # Display the plot in a browser
    fig.show()
# -------------------------------
# Example Usage
# -------------------------------
# Define layer sizes
layer_sizes = [256, 128, 96, 64, 48, 32, 24, 16]
# Build and visualize the model
input_dim = 10  # Example input dimensions
model = build_inner_i_model(input_dim)
plot_3d_inner_i_network_with_info(layer_sizes, save_path=os.path.join(RESULTS_DIR, "inner_i_network.html"))

Training Metrics

The model achieves a validation accuracy of X% after Y epochs, demonstrating its ability to map input data to the hierarchical states of consciousness. These results, along with the loss/accuracy plots, are saved as .png images for review.

Interactive Visualization

The resulting interactive neural map is a visual masterpiece. It shows the relationships between layers. It also highlights the foundational role of the Inner ‘I’.

Contemplation

The Inner ‘I’ Consciousness Model is a bold attempt to bridge the gap between ancient wisdom and modern technology. We combine the seven states of awareness with AI-inspired neural networks. This helps us visualize the interconnected nature of consciousness. It also allows us to better understand it.

This interactive model isn’t just a technical achievement—it’s a philosophical exploration of what it means to be aware. It invites us to contemplate the profound connections between the observer, the observed, and the infinite possibilities of the mind.

References: Maharishi Mahesh Yogi, seven states of consciousness in brief, video

Project: Inner-I-3dcm on GitHub – https://github.com/BeeChains/inner-i-3dcm

Stay in the Now within Inner I Network