Considerations on the technologies needed to build autonomous artificial intelligence

Autonomous artificial intelligence technologies

Autonomous artificial intelligence technology can be defined as technology that has the ability to enable artificial intelligence to learn and solve problems on its own. The following functions are considered necessary to realise these.

• Self-learning: to realise autonomous artificial intelligence, it is necessary to have the ability to improve its own capabilities through learning. This would specifically be the ability to analyse past data and generate/improve its own algorithms based on new information. These will enable it to make more flexible and advanced decisions and predictions.
• Self-decision-making: to realise autonomous artificial intelligence, it is necessary to have the ability to make its own decisions based on a given situation. This will not be a choice from a predetermined set of options using a predetermined algorithm, but rather a choice and algorithm that is generated/changed according to the situation. The closest thing to this functionality would be a self-driving car that analyses information from sensors and drives autonomously, or a medical AI that diagnoses diseases.
• Self-repair: autonomous artificial intelligence requires the ability to repair its own problems in the event of a fault or error. This can be achieved by acquiring/analysing the surrounding conditions of a faulty programme or robot behaviour, performing self-diagnosis and attempting self-repair.
• Self-amplification: autonomous artificial intelligence requires the ability to amplify its own capabilities. This can be achieved, for example, by AI creating new knowledge and knowledge connections for decision-making and improving its own resources and capabilities, in the same way that the human brain expands its intelligence through external stimuli (knowledge).

The following sections provide a discussion of each of these functions.

Self-learning artificial intelligence technology

Self-learning artificial intelligence technologies will be those that can analyse data and improve their own capabilities. In terms of machine learning, it is the ability to generate/improve its own models and algorithms based on new information. The following section discusses the characteristics and mechanisms of self-learning artificial intelligence technologies.

<Features> Self-learning artificial intelligence technologies have the following characteristics.

• Unlike human expert systems (expert systems using artificial intelligence technology), they can autonomously acquire their own knowledge, given a certain amount of initial data and problem settings.
• By learning from past data and generating/modifying the models and algorithms used according to the situation, the system can make advanced predictions and judgements on unknown situations.
• Once acquired, the knowledge is stored and reused. It is also possible to import and re-use externally acquired knowledge.

<Structure> Self-learning artificial intelligence technology can be assumed to learn in the following steps.

• Data collection: the AI collects the data it needs to learn.
• Pre-processing: data is formatted to make it easier to analyse.
• Generate and select learning algorithms: select algorithms for the AI to analyse the data. There are various algorithms available and the best algorithm should be selected according to the nature of the data.
• Learning: the AI analyses the data and stores the acquired knowledge.
• Evaluation: the AI evaluates the results of its learning and re-learns them if necessary.

<Applications> Self-learning artificial intelligence technology is expected to be applied in various fields. Typical applications are described below.

• Self-driving cars: AI that drives automatically will self-learn based on information collected from sensors such as cameras and radar.
• Machine translation: self-learning by an AI that improves its own translation accuracy based on past translation results.
• Medical diagnosis: the AI learns from past cases to diagnose illnesses and suggest treatment plans.

<Example of implementation>

Self-learning using reinforcement learning: a method whereby the agent learns optimal behaviour while receiving feedback (rewards) from the environment.

import gym
import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam

# Initialising the environment
env = gym.make('CartPole-v1')
state_size = env.observation_space.shape[0]
action_size = env.action_space.n

# model building
model = Sequential()
model.add(Dense(24, input_dim=state_size, activation='relu'))
model.add(Dense(24, activation='relu'))
model.add(Dense(action_size, activation='linear'))
model.compile(loss='mse', optimizer=Adam(learning_rate=0.001))

# Reinforcement learning algorithms implemented.
def train_dqn():
    for episode in range(100):
        state = env.reset()
        done = False
        while not done:
            action = np.argmax(model.predict(np.array([state]))[0])
            next_state, reward, done, _ = env.step(action)
            # Save rewards for learning and update models

• Generative models: the AI learns as it generates new data using GANs.

import tensorflow as tf
from tensorflow.keras import layers

# Building the Generator
def build_generator():
    model = tf.keras.Sequential([
        layers.Dense(128, activation='relu', input_dim=100),
        layers.Dense(784, activation='sigmoid')
    ])
    return model

# Building the Discriminator.
def build_discriminator():
    model = tf.keras.Sequential([
        layers.Dense(128, activation='relu', input_dim=784),
        layers.Dense(1, activation='sigmoid')
    ])
    return model

# GAN-wide integration
generator = build_generator()
discriminator = build_discriminator()
discriminator.compile(optimizer='adam', loss='binary_crossentropy')
discriminator.trainable = False

gan_input = tf.keras.Input(shape=(100,))
generated_image = generator(gan_input)
gan_output = discriminator(generated_image)
gan = tf.keras.Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')

• Self-supervised learning: a method in which AI learns features on its own for unlabelled data.

from transformers import AutoTokenizer, AutoModel

# Preparing models and tokenisers.
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModel.from_pretrained("bert-base-uncased")

# Tokenisation of text and input to models.
text = "Artificial intelligence is evolving."
inputs = tokenizer(text, return_tensors="pt")
outputs = model(**inputs)

# output feature
print(outputs.last_hidden_state)

• Evolutionary algorithms: methods that use genetic algorithms to evolve models and solutions.

import numpy as np

# Definition of the adaptivity function
def fitness_function(individual):
    return -np.sum(np.square(individual - target))

# initialisation
population = np.random.uniform(-1, 1, (10, 5))
target = np.array([0.5, 0.5, 0.5, 0.5, 0.5])

# evolutionary algorithm
for generation in range(100):
    fitness_scores = np.array([fitness_function(ind) for ind in population])
    best_individuals = population[np.argsort(fitness_scores)[-5:]]
    # Generation of offspring

Artificial intelligence technology for self-determination

Self-judging artificial intelligence technology is a technology that makes its own decisions in accordance with the rules and criteria possessed by the artificial intelligence itself when making a decision on a certain problem. The following describes the characteristics and mechanisms of artificial intelligence technology that makes its own judgements.

<Features> Artificial intelligence technology that makes its own decisions is considered to have the following features.

• Self-judgement is possible by providing a certain amount of initial data and rules.
• It can make judgements that take into account more complex rules than if a human were to create the rules.
• It can learn in the process of making self-judgements, improving the accuracy and efficiency of its judgements.

<Mechanism> Artificial intelligence technology for self-judgement can be assumed to make decisions in the following steps.

• Rule creation: create the necessary rules for the problem. Rules may be created by humans or automatically by machine learning.
• Analysing input data: the data required to make a decision are analysed and applied to the rules.
• Execution of the judgement: a self-judgement is made according to the rules. The results of the judgement are stored as new data and used for the next judgement.
• Learning: the results of the judgement are evaluated, and the rules are amended if necessary, or the accuracy and efficiency of the judgement is improved.

<Applications> Artificial intelligence technology for self-judgement is applied in a variety of fields. Typical applications are listed below.

• Image recognition: AI makes self-judgments by analysing input images and judging various objects.
• Natural language processing: an AI analyses input natural language, understands the grammar and meaning, and makes a self-judgment to return a response.
• Security measures: AI makes self-judgments to detect anomalies that occur on networks and systems and take countermeasures.

<Example implementation>

Self-determination using decision trees: decision trees are models that automatically make the best choice based on conditional branching.

from sklearn.tree import DecisionTreeClassifier
import numpy as np

# Dataset (features and labels)
X = np.array([[0, 0], [1, 0], [0, 1], [1, 1]])  # [with obstructions, traffic congestion].
y = np.array([0, 1, 2, 3])  # 0: stop, 1: turn right, 2: turn left, 3: proceed

# Decision tree model training.
clf = DecisionTreeClassifier()
clf.fit(X, y)

# Decisions based on new situations.
new_situation = [[1, 1]]  # There are obstacles and traffic jams.
decision = clf.predict(new_situation)
print(f"判断結果: {decision}")

• State transition model: an algorithm that dynamically changes its behaviour according to its state and transitions to the next state.

class ChatBot:
    def __init__(self):
        self.state = "greeting"

    def respond(self, user_input):
        if self.state == "greeting":
            if "hello" in user_input.lower():
                self.state = "info_request"
                return "Hello! How can I assist you today?"
        elif self.state == "info_request":
            if "price" in user_input.lower():
                self.state = "closing"
                return "Our product starts at $100. Anything else?"
        elif self.state == "closing":
            return "Thank you for your inquiry. Have a great day!"

# Chatbot behaviour.
bot = ChatBot()
print(bot.respond("hello"))  # Initial greeting
print(bot.respond("Tell me the price"))  # question
print(bot.respond("Thanks"))  # end

• Probabilistic self-determination through Bayesian inference: using Bayesian inference to make probabilistic decisions based on observed data.

from scipy.stats import norm

# Bayesian inference based on symptom data.
def bayesian_inference(symptom_data, prior_disease_prob=0.1):
    likelihood = norm.pdf(symptom_data, loc=5, scale=2)  # Diseases with an average symptom score of 5.
    posterior_prob = likelihood * prior_disease_prob
    return posterior_prob / (posterior_prob + (1 - prior_disease_prob) * (1 - likelihood))

# Probability of disease with a symptom score of 6.
symptom_score = 6
disease_probability = bayesian_inference(symptom_score)
print(f"病気の確率: {disease_probability:.2f}")

• Dynamic self-decisions using reinforcement learning: the agent learns to make optimal decisions autonomously through interaction with the environment.

import numpy as np

# Q-learning algorithm
q_table = np.zeros((5, 2))  # Table of states x actions

def choose_action(state, epsilon=0.1):
    if np.random.rand() < epsilon:
        return np.random.choice([0, 1])  # random selection
    return np.argmax(q_table[state])

def update_q_table(state, action, reward, next_state, alpha=0.1, gamma=0.9):
    q_table[state, action] = q_table[state, action] + alpha * (
        reward + gamma * np.max(q_table[next_state]) - q_table[state, action]
    )

# Sample of states and behaviours
state = 0
action = choose_action(state)
reward = 10  # reward
next_state = 1
update_q_table(state, action, reward, next_state)
print(q_table)

• Hybrid rule-based and ML models: combines rule-based systems with machine learning models for flexibility and efficiency.

import random

# Rule-based basic pricing.
def base_price(stock_level):
    if stock_level < 10:
        return 100
    elif stock_level < 50:
        return 80
    else:
        return 50

# Demand forecasting with machine learning models.
def predict_demand():
    return random.uniform(0.5, 1.5)  # Demand multiplier (virtual)

# Dynamic price calculation.
stock = 20
price = base_price(stock) * predict_demand()
print(f"在庫: {stock}, 設定価格: {price:.2f}")

Artificial intelligence technology that repairs itself

Self-repairing artificial intelligence technology would be a technology in which an AI with self-repairing capabilities can self-repair its own problems. The features and mechanisms of self-repairing artificial intelligence technology are described below.

<Features> Self-repairing artificial intelligence technology is considered to have the following features.

• AI can perform self-diagnosis and search for algorithms to self-repair problems.
• AI can identify its own faults and defects and develop self-repair procedures to repair the problem.
• A self-repairing AI can be more reliable than a conventionally programmed AI.

<Structure> Self-repairing AI technology is assumed to perform self-repair through the following steps

• Self-diagnosis: the AI performs a self-diagnosis to identify its own problems. In doing so, the AI analyses its own past operating logs to identify the problem.
• Problem classification: the AI can use machine learning to classify problems. As a result of the classification, the AI can identify the steps required for self-healing.
• Developing self-healing procedures: evolutionary algorithms can be used by the AI to develop self-healing procedures. Evolutionary algorithms are methods for finding the optimal solution, allowing the AI to develop the best procedure to solve its own problem.
• Execution of self-healing procedures: an appropriate environment needs to be created for the AI to execute self-healing procedures. In doing so, the AI can ensure that it has the necessary resources to perform the self-healing procedure.

<Example implementation>

Detecting and restarting system anomalies: when a system goes into an abnormal state (e.g. stops responding), the process is automatically restarted.

import os
import time
import requests

def check_server_status(url):
    try:
        response = requests.get(url, timeout=5)
        return response.status_code == 200
    except requests.exceptions.RequestException:
        return False

def restart_server():
    os.system("systemctl restart my_server.service")
    print("Server restarted.")

# Regular checks and repairs
server_url = "http://localhost:8000"
while True:
    if not check_server_status(server_url):
        print("Server not responding. Initiate repair...")
        restart_server()
    time.sleep(60)  # Check every minute.

• Anomaly detection and correction by machine learning: machine learning models are used to learn normal/anomaly patterns and perform repair actions when anomalies occur.

from sklearn.ensemble import IsolationForest
import numpy as np

# Data set of normal sensor values.
sensor_data = np.array([[10], [12], [11], [10], [15], [13], [10]])

# Training of anomaly detection models.
model = IsolationForest(contamination=0.1)
model.fit(sensor_data)

# Check for abnormal sensor values.
def check_and_fix_sensor(sensor_value):
    is_anomaly = model.predict([[sensor_value]])[0] == -1
    if is_anomaly:
        print(f"Anomaly detection: recalibrate the sensor value {sensor_value}.")
        recalibrate_sensor()
    else:
        print(f"The sensor value {sensor_value} is normal.")

def recalibrate_sensor():
    print("Sensor being re-calibrated... Completed.")

# Inspect new sensor values.
new_sensor_value = 30
check_and_fix_sensor(new_sensor_value)

• Self-healing networks: use dynamic routing and redundant configurations to repair communication paths in the event of network failure.

import networkx as nx

# Networking.
G = nx.Graph()
G.add_edges_from([("A", "B"), ("B", "C"), ("C", "D"), ("A", "D")])

# Simulation of connection status
def check_connection(node1, node2):
    return G.has_edge(node1, node2)

def repair_network(node1, node2):
    print(f"Repair the connection between {node1} and {node2}...")
    G.add_edge(node1, node2)
    print(f"Repair complete: connection between {node1} and {node2} rebuilt.")

# Check and repair communications
if not check_connection("A", "C"):
    repair_network("A", "C")
else:
    print("The network is normal.")

• Self-repair using reinforcement learning: learning optimal behaviour to interact with the environment and repair the fault.

import numpy as np

# Initialisation of Q tables
q_table = np.zeros((5, 3))  # State x Action.

def choose_action(state, epsilon=0.1):
    if np.random.rand() < epsilon:
        return np.random.choice([0, 1, 2])  # random behaviour
    return np.argmax(q_table[state])

def update_q_table(state, action, reward, next_state, alpha=0.1, gamma=0.9):
    q_table[state, action] += alpha * (reward + gamma * np.max(q_table[next_state]) - q_table[state, action])

# State transitions and rewards
state = 0  # initial state
for step in range(10):  # repair attempt
    action = choose_action(state)
    if action == 0:
        reward, next_state = -1, 0  # Invalid repair
    elif action == 1:
        reward, next_state = 10, 1  # Repair Success
    else:
        reward, next_state = -5, 0  # Mistaken restoration.
    update_q_table(state, action, reward, next_state)
    state = next_state
    print(q_table)

• Self-healing using log analysis: analyses logs of errors and anomalies to identify and automatically address problems.

import re
import subprocess

def analyze_logs(log_file):
    with open(log_file, "r") as file:
        logs = file.readlines()

    for log in logs:
        if re.search("ERROR: Disk full", log):
            print("Error detected: insufficient disk space. Initiate repair...")
            free_up_space()

def free_up_space():
    subprocess.run(["rm", "-rf", "/tmp/*"])
    print("Unnecessary files deleted.")

# Log analysis and repair
analyze_logs("server_logs.txt")

Self-propagating artificial intelligence technology

<Features> The following components are considered necessary for self-replicating artificial intelligence technology.

• Self-replication function: the basis of self-replicating artificial intelligence is the self-replication function, which enables the AI to replicate itself and generate new artificial intelligences.
• Self-repair function: through repeated self-replication, artificial intelligence acquires a self-repair function. This function allows it to repair itself in the event of damage caused by environmental changes or attacks.
• Learning algorithm: a self-replicating artificial intelligence repeatedly evolves itself through a learning algorithm. This allows new artificial intelligences to improve their adaptive and generalisation performance.
• Control systems: to control a self-reproducing artificial intelligence, an appropriate control system is needed. The control system will include the ability to monitor the behaviour and evolution of the artificial intelligence and limit it as necessary.
• Security measures: self-propagating artificial intelligence, if inadvertently developed, could pose unknown dangers. Security measures are therefore important. Security measures include protection against unauthorised access and attacks, and mechanisms to prevent unauthorised use of artificial intelligence.

<Example implementation>

File-based self-propagating scripts: duplicate a copy of the programme itself in another directory and start a new task.

import os
import shutil

def self_replicate(destination_folder):
    # Get own filename
    current_file = __file__
    # Determine the file path to be duplicated.
    new_file = os.path.join(destination_folder, "replica.py")
    # Duplicate yourself.
    shutil.copy(current_file, new_file)
    print(f"Reproduced in.: {new_file}")

    # Run in a new process
    os.system(f"python {new_file}")

# Specify the destination folder for duplicates.
destination = "./replica_folder"
os.makedirs(destination, exist_ok=True)
self_replicate(destination)

• Self-propagation using evolutionary algorithms: implementation of AI models that not only self-replicate but also evolve (e.g. mutate parameters) during replication.

import random

class AIEntity:
    def __init__(self, parameters):
        self.parameters = parameters  # AI parameters.
        self.fitness = 0  # fitness

    def evaluate(self):
        # Adaptation assessment (e.g. the higher the sum of the parameters, the higher the adaptation)
        self.fitness = sum(self.parameters)

    def reproduce(self):
        # Generate offspring with small mutations in parameters
        new_parameters = [p + random.uniform(-0.1, 0.1) for p in self.parameters]
        return AIEntity(new_parameters)

# Generation of initial populations
population = [AIEntity([random.uniform(0, 1) for _ in range(5)]) for _ in range(10)]

# Simulation of generational change
for generation in range(5):
    print(f"世代 {generation}:")
    # Assessing adaptation
    for entity in population:
        entity.evaluate()

    # Sort by adaptability
    population.sort(key=lambda x: x.fitness, reverse=True)
    print(f"highest fitness level: {population[0].fitness}")

    # Select and replicate the top half
    next_generation = []
    for parent in population[:len(population) // 2]:
        next_generation.append(parent)
        next_generation.append(parent.reproduce())
    population = next_generation

• Distributed multi-agent systems: autonomous, self-replicating agents perform tasks over a network.

import threading
import time
import random

class AIWorker:
    def __init__(self, id, task):
        self.id = id
        self.task = task

    def perform_task(self):
        print(f"Agent {self.id}: running task {self.task}...")
        time.sleep(random.randint(1, 3))
        print(f"Agent {self.id}: completed task {self.task}.")

    def replicate(self):
        new_id = f"{self.id}-child"
        new_task = self.task + 1
        print(f"Agent {self.id}: creates a child agent {new_id}.")
        new_agent = AIWorker(new_id, new_task)
        return new_agent

def agent_thread(agent):
    agent.perform_task()
    if agent.task < 5:  # Limit the maximum number of tasks
        new_agent = agent.replicate()
        thread = threading.Thread(target=agent_thread, args=(new_agent,))
        thread.start()

# Generation of initial agents
initial_agent = AIWorker("Agent-1", 1)
thread = threading.Thread(target=agent_thread, args=(initial_agent,))
thread.start()

• Deploying self-replicating AI models: the AI dynamically multiplies and scales instances of itself in a cloud environment.

import boto3

def replicate_lambda(function_name):
    client = boto3.client('lambda')
    new_function_name = function_name + "-replica"
    response = client.create_function(
        FunctionName=new_function_name,
        Runtime='python3.8',
        Role='your-iam-role',
        Handler='lambda_function.lambda_handler',
        Code={
            'ZipFile': open('function.zip', 'rb').read()
        },
        Description='Self-replicating Lambda functions',
        Timeout=15,
        MemorySize=128
    )
    print(f"New Lambda function {new_function_name} created: {response}")

# Original Lambda function name
original_function = "MyLambdaFunction"
replicate_lambda(original_function)

reference book

References related to autonomous artificial intelligence technologies (self-learning, self-judgment, self-repair and self-amplification) are listed below.

1. self-learning: areas related to self-learning include reinforcement learning, deep learning and transition learning.

BOOKS:
– ‘Reinforcement Learning: An Introduction’ by Richard S. Sutton and Andrew G. Barto.
– This classic book covers the fundamentals and applications of reinforcement learning.
– Ideal for learning how to implement self-learning AI.

– ‘Deep Learning’ by Ian Goodfellow, Yoshua Bengio, and Aaron Courville
– Comprehensive description of deep learning.
– Provides technical background on building self-learning models.

– ‘Transfer Learning for Natural Language Processing’ by Paul Azunre.
– Methods for developing natural language processing models that combine self-learning and transfer learning.

2. self-decision: decision theory, reinforcement learning and game theory are important for self-decision AI.

Book:
– ‘Artificial Intelligence: A Modern Approach’ by Stuart Russell and Peter Norvig.
– A comprehensive overview of AI in general. Includes details of search algorithms and decision-making models for self-determination.

– ‘Decision Theory: Principles and Approaches’ by Giovanni Parmigiani and Lurdes Inoue
– A comprehensive book on decision theory.

– ‘Multi-Agent Systems: Algorithmic, Game-Theoretic, and Logical Foundations’ by Yoav Shoham and Kevin Leyton-Brown
– This book teaches the fundamentals of self-judgement and decision-making in multi-agent systems.

3. self-healing: self-healing AI is related to fault tolerance, self-adaptive systems and self-organising systems.

Book:
– “Assurances for Self-Adaptive Systems: Principles, Models, and Techniques“

– ‘Autonomic Computing: Concepts, Infrastructure, and Applications’ by Manish Parashar and Salim Hariri
– Book for understanding the basic concepts of autonomic computing.

– ‘Fault-Tolerant Systems’ by Israel Koren and C. Mani Krishna
– Fundamentals of building self-healing systems with a special focus on fault-tolerance.

4. self-amplification: self-amplifying AI is related to evolutionary algorithms, distributed systems and scalability design.

Book:
– ‘Genetic Algorithms in Search, Optimisation, and Machine Learning’ by David E. Goldberg.
– Suitable for learning more about genetic algorithms and their applications.

– ‘Distributed Systems: Principles and Paradigms’ by Andrew S. Tanenbaum and Maarten Van Steen
– Provides the knowledge needed to design distributed systems and implement self-propagating AI.

– ‘Swarm Intelligence: from Natural to Artificial Systems’ by Eric Bonabeau, Marco Dorigo, and Guy Theraulaz
– A commentary on swarm intelligence, useful for designing self-amplifying agents.

5. comprehensive techniques and building autonomous AI: these books are useful for building autonomous AI in general.

BOOKS:
– ‘The Master Algorithm: How the Quest for the Ultimate Learning Machine Will Remake Our World’ by Pedro Domingos.
– The content is aimed at a unified theory of overall AI algorithms and provides insights into autonomous AI.

– ‘Designing Autonomous AI: A Learner-Centric Approach’ by Geetesh Bhardwaj.
– Provides a comprehensive overview of design methods for autonomous AI.

– ‘Principles of Artificial Intelligence’ by Nils J. Nilsson
– A classic book on the basic principles of AI.

6. latest research on self-organisation and autonomy.
– ‘Self-Organisation in Biological Systems’ by Scott Camazine et al.
– Provides inspiration for applying self-organisation phenomena in nature to AI systems.

– ‘Complex Adaptive Systems: An Introduction to Computational Models of Social Life’ by John H. Miller and Scott E. Page.
– Studied the relationship between modelling complex adaptive systems and AI autonomy.