Laut einer aktuellen Studie der Hebräischen Universität, die in der Zeitschrift veröffentlicht wurde, weisen KI-Systeme vorhersehbare und systematische Vorurteile bei der Beurteilung von Menschen auf Verfahren der Royal Society. Die Studie analysierte über 43.000 simulierte Entscheidungen zusammen mit etwa 1.000 menschlichen Teilnehmern in fünf Szenarien und zeigte erhebliche Unterschiede zwischen menschlichen und KI-Bewertungen auf.

Die Szenarien umfassten finanzielle Entscheidungen wie die Kreditvergabe an einen Kleinunternehmer, aber auch soziale Urteile wie die Beurteilung eines Babysitters oder die Entscheidung, wie viel man einem gemeinnützigen Gründer spenden sollte. Die Ergebnisse deuten darauf hin, dass sowohl Menschen als auch KI Individuen bevorzugen, die als kompetent, ehrlich und wohlmeinend wahrgenommen werden, Maschinen jedoch anhand starrer Bewertungskriterien arbeiten, anstatt ganzheitliche Eindrücke zu vermitteln.

Prof. Yaniv Dover bemerkte: „KI trifft keine zufälligen Entscheidungen. Sie erfasst etwas Reales darüber, wie Menschen einander bewerten.“ Die Studie stellte jedoch fest, dass Menschen dazu neigen, allgemeine Eindrücke auf der Grundlage mehrerer Merkmale zu erzeugen, während KI Merkmale wie Kompetenz und Integrität eher segmentiert bewertet. Valeria Lerman erklärte weiter: „Die Menschen in unserer Studie beurteilen andere chaotisch und ganzheitlich. KI ist sauberer, systematischer und das kann zu sehr unterschiedlichen Ergebnissen führen.“

Unterschiede in den Bewertungsergebnissen waren selbst dann offensichtlich, wenn identische Angaben zu den Probanden verwendet wurden. Die Forscher fanden heraus, dass die Vorurteile der KI systematischer und manchmal stärker sein könnten als die des Menschen. In Finanzszenarien zeigten KI-Systeme konsistente Vorurteile zugunsten älterer Menschen und wurden von Aspekten wie Faith und Geschlecht beeinflusst. „Menschen haben natürlich Vorurteile“, sagte Dover. „Aber was uns überrascht hat, ist, dass die Vorurteile der KI systematischer, vorhersehbarer und manchmal stärker sein können.“

Die Studie ergab, dass unterschiedliche KI-Modelle oft zu unterschiedlichen Urteilen über dieselbe Individual führen. Diese Variabilität unterstreicht die Bedeutung der Auswahl von KI-Modellen für die Bestimmung realer Ergebnisse. „Welches Modell Sie verwenden, ist wirklich wichtig“, bemerkte Lerman. Derzeit werden große Sprachmodelle für die Auswahl von Bewerbern, die Bonitätsbeurteilung und andere Entscheidungsprozesse eingesetzt.

Während KI menschliche Urteilsprozesse nachahmt, fanden die Forscher, dass sie weniger nuanciert und starrer ist, oft mit Vorurteilen, die schwerer zu erkennen sind. „Diese Systeme sind leistungsstark“, betonte Dover. „Sie können Aspekte des menschlichen Denkens auf konsistente Weise modellieren. Aber sie sind keine Menschen, und wir sollten nicht davon ausgehen, dass sie Menschen auf die gleiche Weise sehen wie wir.“

Die Forscher plädieren für ein tieferes Verständnis der Bewertungsprozesse von KI, während sich diese Werkzeuge von Assistenten zu Entscheidungsträgern weiterentwickeln. Sie stellen klar, dass das Ziel nicht darin besteht, den Einsatz von KI zu unterbinden, sondern das Bewusstsein dafür zu schärfen, wie sehr diese Systeme Einzelpersonen vertrauen. „Die Frage ist nicht mehr, ob wir Maschinen vertrauen, sondern ob wir verstehen, wie sie uns vertrauen“, heißt es in der Studie.

Hervorgehobener Bildnachweis

In diesem Tutorial programmieren wir ein Mini-Setup für verstärktes Lernen, in dem ein Multi-Agenten-System lernt, durch Interaktion, Suggestions und mehrschichtige Entscheidungsfindung in einer Grid-Welt zu navigieren. Wir bauen alles von Grund auf auf und vereinen drei Agentenrollen: einen Aktionsagenten, einen Werkzeugagenten und einen Supervisor, damit wir beobachten können, wie einfache Heuristiken, Analysen und Aufsicht zusammen zu intelligenterem Verhalten führen. Außerdem beobachten wir, wie die Agenten zusammenarbeiten, ihre Strategien verfeinern und nach und nach lernen, das Ziel zu erreichen und dabei Hindernisse und Unsicherheiten zu überwinden. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

import numpy as np
import matplotlib.pyplot as plt
from IPython.show import clear_output
import time
from collections import defaultdict


class GridWorld:
   def __init__(self, measurement=8):
       self.measurement = measurement
       self.agent_pos = (0, 0)
       self.goal_pos = (size-1, size-1)
       self.obstacles = self._generate_obstacles()
       self.visited = set()
       self.step_count = 0
       self.max_steps = measurement * measurement * 2
      
   def _generate_obstacles(self):
       obstacles = set()
       n_obstacles = self.measurement
       whereas len(obstacles) < n_obstacles:
           pos = (np.random.randint(1, self.size-1),
                  np.random.randint(1, self.size-1))
           if pos != (0, 0) and pos != (self.size-1, self.size-1):
               obstacles.add(pos)
       return obstacles
  
   def reset(self):
       self.agent_pos = (0, 0)
       self.visited = {tuple(self.agent_pos)}
       self.step_count = 0
       return self._get_state()
  
   def _get_state(self):
       return {
           'place': tuple(self.agent_pos),
           'objective': self.goal_pos,
           'distance_to_goal': abs(self.agent_pos(0) - self.goal_pos(0)) +
                               abs(self.agent_pos(1) - self.goal_pos(1)),
           'visited_count': len(self.visited),
           'steps': self.step_count,
           'can_move': self._get_valid_actions()
       }
  
   def _get_valid_actions(self):
       legitimate = ()
       strikes = {'up': (-1, 0), 'down': (1, 0), 'left': (0, -1), 'proper': (0, 1)}
       for motion, delta in strikes.gadgets():
           new_pos = (self.agent_pos(0) + delta(0), self.agent_pos(1) + delta(1))
           if (0 <= new_pos(0) < self.measurement and 0 <= new_pos(1) < self.measurement and
               tuple(new_pos) not in self.obstacles):
               legitimate.append(motion)
       return legitimate

Wir richten die gesamte GridWorld-Umgebung ein und definieren, wie der Agent, das Ziel und die Hindernisse darin existieren. Wir schaffen die Struktur für die staatliche Repräsentation und gültige Bewegungen und bereiten die Umgebung vor, damit wir dynamisch mit ihr interagieren können. Während wir diesen Teil abarbeiten, sehen wir, wie die Welt Gestalt annimmt und für die Erkundung durch die Agenten bereit ist. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class GridWorld(GridWorld):
   def step(self, motion):
       self.step_count += 1
       strikes = {'up': (-1, 0), 'down': (1, 0), 'left': (0, -1), 'proper': (0, 1)}
      
       if motion not in strikes:
           return self._get_state(), -1, False, "Invalid motion"
      
       delta = strikes(motion)
       new_pos = (self.agent_pos(0) + delta(0), self.agent_pos(1) + delta(1))
      
       if not (0 <= new_pos(0) < self.measurement and 0 <= new_pos(1) < self.measurement):
           return self._get_state(), -1, False, "Hit wall"
      
       if tuple(new_pos) in self.obstacles:
           return self._get_state(), -1, False, "Hit impediment"
      
       self.agent_pos = new_pos
       pos_tuple = tuple(self.agent_pos)
       reward = -0.1
       if pos_tuple not in self.visited:
           reward += 0.5
           self.visited.add(pos_tuple)
      
       performed = False
       information = "Moved"
       if self.agent_pos == self.goal_pos:
           reward += 10
           performed = True
           information = "Aim reached!"
       elif self.step_count >= self.max_steps:
           performed = True
           information = "Max steps reached"
      
       return self._get_state(), reward, performed, information
  
   def render(self, agent_thoughts=None):
       grid = np.zeros((self.measurement, self.measurement, 3))
       for pos in self.visited:
           grid(pos(0), pos(1)) = (0.7, 0.9, 1.0)
       for obs in self.obstacles:
           grid(obs(0), obs(1)) = (0.2, 0.2, 0.2)
       grid(self.goal_pos(0), self.goal_pos(1)) = (0, 1, 0)
       grid(self.agent_pos(0), self.agent_pos(1)) = (1, 0, 0)
      
       plt.determine(figsize=(10, 8))
       plt.imshow(grid, interpolation='nearest')
       plt.title(f"Step: {self.step_count} | Visited: {len(self.visited)}/{self.measurement*self.measurement}")
       for i in vary(self.measurement + 1):
           plt.axhline(i - 0.5, colour="grey", linewidth=0.5)
           plt.axvline(i - 0.5, colour="grey", linewidth=0.5)
       if agent_thoughts:
           plt.textual content(0.5, -1.5, agent_thoughts, ha="heart", fontsize=9,
                    bbox=dict(boxstyle="spherical", facecolor="wheat", alpha=0.8),
                    wrap=True, remodel=plt.gca().transData)
       plt.axis('off')
       plt.tight_layout()
       plt.present()

Wir definieren, wie jeder Schritt in der Umgebung funktioniert und wie die Welt visuell dargestellt wird. Wir berechnen Belohnungen, erkennen Kollisionen, verfolgen den Fortschritt und zeigen alles durch eine übersichtliche Rastervisualisierung an. Während wir diese Logik umsetzen, beobachten wir die Reise des Agenten in Echtzeit mit klarem Suggestions. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class ActionAgent:
   def __init__(self):
       self.q_values = defaultdict(lambda: defaultdict(float))
       self.epsilon = 0.3
       self.learning_rate = 0.1
       self.low cost = 0.95
  
   def choose_action(self, state):
       valid_actions = state('can_move')
       if not valid_actions:
           return None
       pos = state('place')
       if np.random.random() < self.epsilon:
           motion = np.random.alternative(valid_actions)
           reasoning = f"Exploring randomly: selected '{motion}'"
       else:
           action_values = {a: self.q_values(pos)(a) for a in valid_actions}
           motion = max(action_values, key=action_values.get)
           reasoning = f"Exploiting: selected '{motion}' (Q={self.q_values(pos)(motion):.2f})"
       return motion, reasoning
  
   def be taught(self, state, motion, reward, next_state):
       pos = state('place')
       next_pos = next_state('place')
       current_q = self.q_values(pos)(motion)
       next_max_q = max((self.q_values(next_pos)(a) for a in next_state('can_move')), default=0)
       new_q = current_q + self.learning_rate * (
           reward + self.low cost * next_max_q - current_q)
       self.q_values(pos)(motion) = new_q


class ToolAgent:
   def analyze(self, state, action_taken, reward, historical past):
       options = ()
       distance = state('distance_to_goal')
       if distance <= 3:
           options.append(" Very near objective! Prioritize direct path.")
       exploration_rate = state('visited_count') / (state('steps') + 1)
       if exploration_rate < 0.5 and distance > 5:
           options.append(" Low exploration fee. Take into account exploring extra.")
       if len(historical past) >= 5:
           recent_rewards = (h(2) for h in historical past(-5:))
           avg_reward = np.imply(recent_rewards)
           if avg_reward < -0.5:
               options.append(" Detrimental reward development. Attempt completely different technique.")
           elif avg_reward > 0.3:
               options.append(" Good progress! Present technique working.")
       if len(state('can_move')) <= 2:
           options.append(" Restricted motion choices. Watch out.")
       return options

Wir implementieren den Motion Agent und Device Agent und verleihen dem System sowohl Lernfähigkeit als auch analytisches Suggestions. Wir beobachten, wie der Motion Agent Aktionen durch ein ausgewogenes Verhältnis von Exploration und Exploitation auswählt, während der Device Agent die Leistung bewertet und Verbesserungen vorschlägt. Gemeinsam bilden sie eine Lernschleife, die sich mit der Erfahrung weiterentwickelt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class SupervisorAgent:
   def resolve(self, state, proposed_action, tool_suggestions):
       if not proposed_action:
           return None, "No legitimate actions accessible"
      
       choice = proposed_action
       reasoning = f"Authorized motion '{proposed_action}'"
      
       for suggestion in tool_suggestions:
           if "objective" in suggestion.decrease() and "shut" in suggestion.decrease():
               goal_direction = self._get_goal_direction(state)
               if goal_direction in state('can_move'):
                   choice = goal_direction
                   reasoning = f"Override: Transferring '{goal_direction}' towards objective"
                   break
      
       return choice, reasoning
  
   def _get_goal_direction(self, state):
       pos = state('place')
       objective = state('objective')
       if objective(0) > pos(0):
           return 'down'
       elif objective(0) < pos(0):
           return 'up'
       elif objective(1) > pos(1):
           return 'proper'
       else:
           return 'left'

Wir stellen den Supervisor Agent vor, der als letzter Entscheidungsträger im System fungiert. Wir sehen, wie es Vorschläge interpretiert, riskante Entscheidungen außer Kraft setzt und sicherstellt, dass die Maßnahmen mit den Gesamtzielen im Einklang bleiben. Wenn wir diese Komponente verwenden, erleben wir einen koordinierten Entscheidungsfluss mit mehreren Agenten. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def train_multi_agent(episodes=5, visualize=True):
   env = GridWorld(measurement=8)
   action_agent = ActionAgent()
   tool_agent = ToolAgent()
   supervisor = SupervisorAgent()
  
   episode_rewards = ()
   episode_steps = ()
  
   for episode in vary(episodes):
       state = env.reset()
       total_reward = 0
       performed = False
       historical past = ()
      
       print(f"n{'='*60}")
       print(f"EPISODE {episode + 1}/{episodes}")
       print(f"{'='*60}")
      
       whereas not performed:
           action_result = action_agent.choose_action(state)
           if action_result is None:
               break
           proposed_action, action_reasoning = action_result
          
           options = tool_agent.analyze(state, proposed_action, total_reward, historical past)
           final_action, supervisor_reasoning = supervisor.resolve(state, proposed_action, options)
          
           if final_action is None:
               break
          
           next_state, reward, performed, information = env.step(final_action)
           total_reward += reward
           action_agent.be taught(state, final_action, reward, next_state)
           historical past.append((state, final_action, reward, next_state))
          
           if visualize:
               clear_output(wait=True)
               ideas = (f"Motion Agent: {action_reasoning}n"
                          f"Supervisor: {supervisor_reasoning}n"
                          f"Device Agent: {', '.be a part of(options(:2)) if options else 'No options'}n"
                          f"Reward: {reward:.2f} | Complete: {total_reward:.2f}")
               env.render(ideas)
               time.sleep(0.3)
          
           state = next_state
      
       episode_rewards.append(total_reward)
       episode_steps.append(env.step_count)
      
       print(f"nEpisode {episode+1} Full!")
       print(f"Complete Reward: {total_reward:.2f}")
       print(f"Steps Taken: {env.step_count}")
       print(f"Cells Visited: {len(env.visited)}/{env.measurement**2}")
  
   plt.determine(figsize=(12, 4))
   plt.subplot(1, 2, 1)
   plt.plot(episode_rewards, marker="o")
   plt.title('Episode Rewards')
   plt.xlabel('Episode')
   plt.ylabel('Complete Reward')
   plt.grid(True, alpha=0.3)
  
   plt.subplot(1, 2, 2)
   plt.plot(episode_steps, marker="s", colour="orange")
   plt.title('Episode Steps')
   plt.xlabel('Episode')
   plt.ylabel('Steps to Full')
   plt.grid(True, alpha=0.3)
   plt.tight_layout()
   plt.present()
  
   return action_agent, tool_agent, supervisor


if __name__ == "__main__":
   print(" Multi-Agent RL System: Grid World Navigation")
   print("=" * 60)
   print("Parts:")
   print("  • Motion Agent: Proposes actions utilizing Q-learning")
   print("  • Device Agent: Analyzes efficiency and suggests enhancements")
   print("  • Supervisor Agent: Makes last selections")
   print("=" * 60)
  
   trained_agents = train_multi_agent(episodes=5, visualize=True)

Wir führen die gesamte Trainingsschleife durch, in der alle Agenten über mehrere Episoden hinweg innerhalb der Umgebung zusammenarbeiten. Wir verfolgen Belohnungen, beobachten Bewegungsmuster und visualisieren den Lernfortschritt bei jedem Versuch. Wenn wir diese Schleife abschließen, sehen wir, dass sich das Multi-Agenten-System verbessert und effizienter in der Grid-Welt navigiert.

Abschließend sehen wir, wie aus sauberen Komponenten ein Multi-Agenten-RL-System entsteht und wie jede Schicht zu einer intelligenteren Navigation beiträgt: Der Motion Agent lernt über Q-Updates, der Device Agent leitet Verbesserungen an und der Supervisor sorgt für eine sichere, zielorientierte Aktionsauswahl. Wir wissen zu schätzen, wie diese einfache, aber dynamische Rasterwelt uns dabei hilft, Lernen, Erkunden und Entscheidungsfindung in Echtzeit zu visualisieren.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

class AdvancedNeuralAgent:
   def __init__(self, input_size, hidden_layers=(64, 32), output_size=1, learning_rate=0.001):
       """Superior AI Agent with steady coaching and choice making capabilities"""
       self.lr = learning_rate
       self.initial_lr = learning_rate
       self.layers = ()
       self.reminiscence = ()
       self.performance_history = ()
       self.epsilon = 1e-8 
      
       layer_sizes = (input_size) + hidden_layers + (output_size)
       for i in vary(len(layer_sizes) - 1):
           fan_in, fan_out = layer_sizes(i), layer_sizes(i+1)
           restrict = np.sqrt(6.0 / (fan_in + fan_out))
          
           layer = {
               'weights': np.random.uniform(-limit, restrict, (layer_sizes(i), layer_sizes(i+1))),
               'bias': np.zeros((1, layer_sizes(i+1))),
               'momentum_w': np.zeros((layer_sizes(i), layer_sizes(i+1))),
               'momentum_b': np.zeros((1, layer_sizes(i+1)))
           }
           self.layers.append(layer)
  
   def activation(self, x, func="relu"):
       """Steady activation features with clipping"""
       x = np.clip(x, -50, 50) 
      
       if func == 'relu':
           return np.most(0, x)
       elif func == 'sigmoid':
           return 1 / (1 + np.exp(-x))
       elif func == 'tanh':
           return np.tanh(x)
       elif func == 'leaky_relu':
           return np.the place(x > 0, x, x * 0.01)
       elif func == 'linear':
           return x
  
   def activation_derivative(self, x, func="relu"):
       """Steady derivatives"""
       x = np.clip(x, -50, 50)
      
       if func == 'relu':
           return (x > 0).astype(float)
       elif func == 'sigmoid':
           s = self.activation(x, 'sigmoid')
           return s * (1 - s)
       elif func == 'tanh':
           return 1 - np.tanh(x)**2
       elif func == 'leaky_relu':
           return np.the place(x > 0, 1, 0.01)
       elif func == 'linear':
           return np.ones_like(x)
  
   def ahead(self, X):
       """Ahead move with gradient clipping"""
       self.activations = (X)
       self.z_values = ()
      
       current_input = X
       for i, layer in enumerate(self.layers):
           z = np.dot(current_input, layer('weights')) + layer('bias')
           z = np.clip(z, -50, 50) 
           self.z_values.append(z)
          
           if i < len(self.layers) - 1: 
               a = self.activation(z, 'leaky_relu')
           else: 
               a = self.activation(z, 'linear')
          
           self.activations.append(a)
           current_input = a
      
       return current_input
  
   def clip_gradients(self, gradients, max_norm=1.0):
       """Gradient clipping to forestall explosion"""
       grad_norm = np.linalg.norm(gradients)
       if grad_norm > max_norm:
           gradients = gradients * (max_norm / (grad_norm + self.epsilon))
       return gradients
  
   def backward(self, X, y, output):
       """Steady backpropagation with gradient clipping"""
       m = X.form(0)
      
       dz = (output - y.reshape(-1, 1)) / m
       dz = np.clip(dz, -10, 10)
      
       for i in reversed(vary(len(self.layers))):
           layer = self.layers(i)
          
           dw = np.dot(self.activations(i).T, dz)
           db = np.sum(dz, axis=0, keepdims=True)
          
           dw = self.clip_gradients(dw, max_norm=1.0)
           db = self.clip_gradients(db, max_norm=1.0)
          
           momentum = 0.9
           layer('momentum_w') = momentum * layer('momentum_w') + (1 - momentum) * dw
           layer('momentum_b') = momentum * layer('momentum_b') + (1 - momentum) * db
          
           weight_decay = 0.0001
           layer('weights') -= self.lr * (layer('momentum_w') + weight_decay * layer('weights'))
           layer('bias') -= self.lr * layer('momentum_b')
          
           if i > 0:
               activation_func="leaky_relu" if i > 1 else 'leaky_relu'
               dz = np.dot(dz, layer('weights').T) * self.activation_derivative(
                   self.z_values(i-1), activation_func)
               dz = np.clip(dz, -10, 10) 
  
   def adapt_learning_rate(self, epoch, performance_history):
       """Adaptive studying fee with performance-based adjustment"""
       if epoch > 10:
           recent_performance = performance_history(-10:)
           if len(recent_performance) >= 5:
               if recent_performance(-1) >= recent_performance(-5):
                   self.lr = max(self.lr * 0.95, self.initial_lr * 0.01)
               elif recent_performance(-1) < recent_performance(-5) * 0.98:
                   self.lr = min(self.lr * 1.02, self.initial_lr * 2)
  
   def calculate_loss(self, y_true, y_pred):
       """Steady loss calculation"""
       y_true = y_true.reshape(-1, 1)
       y_pred = np.clip(y_pred, -1e6, 1e6) 
      
       mse = np.imply((y_true - y_pred) ** 2)
       mae = np.imply(np.abs(y_true - y_pred))
      
       if not np.isfinite(mse):
           mse = 1e6
       if not np.isfinite(mae):
           mae = 1e6
          
       return mse, mae
  
   def store_experience(self, state, motion, reward, next_state):
       """Expertise replay for RL points"""
       expertise = {
           'state': state,
           'motion': motion,
           'reward': reward,
           'next_state': next_state,
           'timestamp': len(self.reminiscence)
       }
       self.reminiscence.append(expertise)
      
       if len(self.reminiscence) > 1000:
           self.reminiscence.pop(0)
  
   def make_decision(self, X, exploration_rate=0.1):
       """Steady choice making"""
       prediction = self.ahead(X)
      
       if np.random.random() < exploration_rate:
           noise_scale = np.std(prediction) * 0.1 if np.std(prediction) > 0 else 0.1
           noise = np.random.regular(0, noise_scale, prediction.form)
           prediction += noise
      
       return np.clip(prediction, -1e6, 1e6)
  
   def reset_if_unstable(self):
       """Reset community if coaching turns into unstable"""
       print(" Resetting community as a result of instability...")
       for i, layer in enumerate(self.layers):
           fan_in, fan_out = layer('weights').form
           restrict = np.sqrt(6.0 / (fan_in + fan_out))
           layer('weights') = np.random.uniform(-limit, restrict, (fan_in, fan_out))
           layer('bias') = np.zeros((1, fan_out))
           layer('momentum_w') = np.zeros((fan_in, fan_out))
           layer('momentum_b') = np.zeros((1, fan_out))
       self.lr = self.initial_lr
  
   def practice(self, X, y, epochs=500, batch_size=32, validation_split=0.2, verbose=True):
       """Strong coaching with stability checks"""
       y_mean, y_std = np.imply(y), np.std(y)
       y_normalized = (y - y_mean) / (y_std + self.epsilon)
      
       X_trn, X_val, y_trn, y_val = train_test_split(
           X, y_normalized, test_size=validation_split, random_state=42)
      
       best_val_loss = float('inf')
       endurance = 30
       patience_counter = 0
      
       train_losses, val_losses = (), ()
       reset_count = 0
      
       for epoch in vary(epochs):
           if epoch > 0 and (not np.isfinite(train_losses(-1)) or train_losses(-1) > 1e6):
               if reset_count < 2: 
                   self.reset_if_unstable()
                   reset_count += 1
                   proceed
               else:
                   print(" Coaching unstable, stopping...")
                   break
          
           indices = np.random.permutation(len(X_train))
           X_train_shuffled = X_train(indices)
           y_train_shuffled = y_train(indices)
          
           epoch_loss = 0
           batches = 0
           for i in vary(0, len(X_trn), batch_size):
               batch_X = X_train_shuffled(i:i+batch_size)
               batch_y = y_train_shuffled(i:i+batch_size)
              
               if len(batch_X) == 0:
                   proceed
              
               output = self.ahead(batch_X)
               self.backward(batch_X, batch_y, output)
              
               loss, _ = self.calculate_loss(batch_y, output)
               epoch_loss += loss
               batches += 1
          
           avg_train_loss = epoch_loss / max(batches, 1)
          
           val_output = self.ahead(X_val)
           val_loss, val_mae = self.calculate_loss(y_val, val_output)
          
           train_losses.append(avg_train_loss)
           val_losses.append(val_loss)
           self.performance_history.append(val_loss)
          
           if val_loss < best_val_loss:
               best_val_loss = val_loss
               patience_counter = 0
           else:
               patience_counter += 1
          
           if patience_counter >= endurance:
               if verbose:
                   print(f" Early stopping at epoch {epoch}")
               break
          
           if epoch > 0:
               self.adapt_learning_rate(epoch, self.performance_history)
          
           if verbose and (epoch % 50 == 0 or epoch < 10):
               print(f"Epoch {epoch:3d}: Practice Loss = {avg_train_loss:.4f}, "
                     f"Val Loss = {val_loss:.4f}, LR = {self.lr:.6f}")
      
       self.y_mean, self.y_std = y_mean, y_std
       return train_losses, val_losses
  
   def predict(self, X):
       """Make predictions with denormalization"""
       normalized_pred = self.ahead(X)
       if hasattr(self, 'y_mean') and hasattr(self, 'y_std'):
           return normalized_pred * self.y_std + self.y_mean
       return normalized_pred
  
   def evaluate_performance(self, X, y):
       """Complete efficiency analysis"""
       predictions = self.predict(X)
       mse, mae = self.calculate_loss(y, predictions)
      
       y_mean = np.imply(y)
       ss_tot = np.sum((y - y_mean) ** 2)
       ss_res = np.sum((y.reshape(-1, 1) - predictions) ** 2)
       r2 = 1 - (ss_res / (ss_tot + self.epsilon))
      
       return {
           'mse': float(mse) if np.isfinite(mse) else float('inf'),
           'mae': float(mae) if np.isfinite(mae) else float('inf'),
           'r2': float(r2) if np.isfinite(r2) else -float('inf'),
           'predictions': predictions.flatten()
       }
  
   def visualize_training(self, train_losses, val_losses):
       """Visualize coaching progress"""
       plt.determine(figsize=(15, 5))
      
       plt.subplot(1, 3, 1)
       plt.plot(train_losses, label="Coaching Loss", alpha=0.8)
       plt.plot(val_losses, label="Validation Loss", alpha=0.8)
       plt.title('Coaching Progress')
       plt.xlabel('Epoch')
       plt.ylabel('Loss')
       plt.legend()
       plt.grid(True, alpha=0.3)
       plt.yscale('log')
      
       plt.subplot(1, 3, 2)
       if len(self.performance_history) > 0:
           plt.plot(self.performance_history)
           plt.title('Efficiency Historical past')
           plt.xlabel('Epoch')
           plt.ylabel('Validation Loss')
           plt.grid(True, alpha=0.3)
           plt.yscale('log')
      
       plt.subplot(1, 3, 3)
       if hasattr(self, 'lr_history'):
           plt.plot(self.lr_history)
           plt.title('Studying Charge Schedule')
           plt.xlabel('Epoch')
           plt.ylabel('Studying Charge')
           plt.grid(True, alpha=0.3)
      
       plt.tight_layout()
       plt.present()

Wir haben viel über einige der Vorteile der Verwendung von KI gesprochen, um ein Unternehmen zu führen. Es ist kein Wunder, dass Unternehmen auf der ganzen Welt voraussichtlich erwartet werden geben Sie über 244 Milliarden US -Greenback für KI aus bis Ende dieses Jahres.

Einer der Hauptgründe, warum Unternehmen KI verwenden, ist die Verbesserung ihrer Entscheidungsfindung. Deshalb suchen mehr von ihnen nach einer AI Options -Entwicklungsunternehmen wie 8alclocate. Lesen Sie weiter, um mehr zu erfahren.

Weitere Unternehmen umfassen KI, um intelligentere Entscheidungen zu treffen

Wie wir in einem früheren Artikel erwähnt haben, ist AI Ändern der Artwork und Weise, wie Unternehmen Geschäfte für immer machen. Das größte Beispiel dafür ist, wie es die Entscheidungsfindung verbessert.

Künstliche Intelligenz ist für Unternehmen, die in quick jeder Abteilung bessere Entscheidungen treffen möchten, mächtig geworden. Es kann bei allem helfen, von der Einstellung bis zur Prognose und sogar der Vertragsüberprüfung. Mehr Unternehmen verwenden KI nicht nur, um Zahlen leichter zu knüpfen, sondern um zu verbessern, wie Entscheidungen getroffen werden. Eine kürzlich durchgeführte Umfrage ergab, dass dies festgestellt wurde 92% der Geschäftsführer Die Unternehmen sollten KI einsetzen, um bei der Entscheidungsfindung zu helfen. Andere Untersuchungen haben gezeigt, dass es bereits passiert. Eine andere Umfrage ergab, dass 79% der Unternehmen angeben, dass sie KI verwenden, um ihre Entscheidungsprozesse zu verbessern.

Sie verwenden es nicht nur, weil es schneller ist und die Kosten senken kann. Rund 47% der Unternehmen glauben, dass KI sie in den Augen von Kunden, Investoren und sogar Aufsichtsbehörden glaubwürdiger machen wird. Dieses Vertrauen kommt zum Teil, wenn sie bessere Entscheidungen schneller treffen und diese Entscheidungen mit klaren Daten unterstützen können.

Jaideep Matto, Chief Knowledge Officer der CIMB Financial institution, hat LinkedIn mitgeteilt, wie Unternehmen wie Amazon und Tesla genau das tun. Amazon verwendet KI, um die Kundennachfrage vorherzusagen, was die Artwork und Weise verändert hat, wie ihre Lieferketten laufen. Tesla nimmt Echtzeitdaten von den Sensoren seiner Autos auf, um nicht nur die Benutzererfahrung, sondern auch die Sicherheit zu verbessern. Diese Artwork von Beispielen konzentrieren sich tendenziell auf kundenorientierte Vorteile, aber es gibt eine ganze Seite der KI, die hinter den Kulissen arbeitet und so vor dem Auswirkungen auf den Markt die Artwork und Weise beeinflusst, wie interne Entscheidungen getroffen werden.

Eine der besten Fallstudien ist bei JP Morgan. Die Financial institution verwendet ein System namens Coin, das rechtliche Dokumente überprüft und analysiert. Anstelle von Wochen der Überprüfung kann Coin 12.000 kommerzielle Kreditvereinbarungen in Sekundenschnelle verarbeiten. Das ist kein zukünftiges Ziel – das ist es, was sie jetzt tun. Und es ändert sich, wie die Rechts- und Compliance-Abteilungen funktionieren können, und verändern Sie den Fokus vom Papierkram auf höheres Denken. Dies ist eines der besten Beispiele von Wie KI die Finanzbranche verändert.

Unter großen Unternehmen ist diese Verschiebung bereits intestine im Gange. 60 Prozent der Unternehmen mit mehr als 10.000 Mitarbeitern verwenden KI in mehreren Abteilungen. Für kleinere Unternehmen schließt sich die Lücke schnell, da mehr Instruments zugänglich und einfacher zu implementieren.

Hier kommt ein Unternehmen wie 8allocation ins Spiel. Der 2015 gegründete und ansässige Unternehmen in Tallinn, Estland, 8allocation ist ein AI -Lösungs -Entwicklungsunternehmen mit F & E -Zentren, die in Mittel- und Osteuropa verteilt sind. Sie sind darauf spezialisiert, Unternehmen dabei zu helfen, den Betrieb zu automatisieren und prädiktive Analysen auf reale Geschäftsprobleme anzuwenden. Sie haben über 200 Projekte abgeschlossen und können in nur einer Woche einen neuen starten. Andrey Kalyuzhnyy, Mitbegründer und geschäftsführender Companion, hat das Wachstum des Unternehmens für Unternehmen, die mit KI aufbauen möchten, in einen vertrauenswürdigen Namen geführt, aber nicht über die Ressourcen oder die Zeit haben, dies allein zu tun.

Natürlich bewegt sich nicht jedes Unternehmen mit der gleichen Geschwindigkeit. Einige Führungskräfte denken immer noch, dass KI zu kompliziert oder nicht die richtige Passform. Aber der Schwung zeigt eindeutig in eine Richtung. Unternehmen, die heute in intelligentere Entscheidungsinstrumente investieren, dürften morgen voraus sein.

Einige Leute sagen, dass KI Dinge zu automatisch macht. Andere denken, es nimmt einfach Jobs weg. Das könnte in einigen Situationen wahr sein. Aber in vielen weiteren Zeiten öffnet es die Zeit für die Menschen, sich auf sinnvollere Arbeiten zu konzentrieren – die Artwork von Arbeitsmaschinen kann es nicht wirklich tun.

Die Entscheidungsfindung wird immer ein menschliches Factor beinhalten, aber immer mehr wird es von Werkzeugen unterstützt, die niemals schlafen, nie vergessen und nie aufhören zu lernen.

Nutzung der Pakete Quanteda, Textstem und Sentimer, um Kundeneinblicke zu gewinnen und die Geschäftsstrategie zu verbessern

13 Min. Lektüre

·

Vor 13 Stunden

In einer sich schnell entwickelnden Welt, die von Minute zu Minute mehr KI-gesteuert wird, müssen Unternehmen nun ständig nach einem Wettbewerbsvorteil streben, um zukunftsfähig zu bleiben. Unternehmen können dies tun, indem sie regelmäßig die Meinungen der Kunden zu ihren Produkten und Dienstleistungen beobachten und analysieren. Dies erreichen sie durch die Auswertung von Kommentaren aus vielen Quellen, sowohl on-line als auch offline. Das Erkennen positiver und negativer Traits im Kundenfeedback ermöglicht es ihnen, Produktfunktionen zu optimieren und Marketingstrategien zu entwickeln, die den Bedürfnissen der Kunden entsprechen.

Daher müssen Kundenmeinungen angemessen berücksichtigt werden, um wertvolle Erkenntnisse zu gewinnen, die dabei helfen können, fundierte Geschäftsentscheidungen zu treffen.

Die Stimmungsanalyse, ein Teil der Verarbeitung natürlicher Sprache (NLP), ist heutzutage eine beliebte Technik, da sie die Meinungen, Gefühle und Emotionen von Menschen in einem bestimmten Textual content untersucht. Unternehmen können die öffentliche Meinung verstehen, die Marke überwachen …

Der Decube KI-Assistent lässt sich problemlos in vorhandene Dateninfrastrukturen integrieren, um Dateneinblicke zu transformieren

Decubeein Pionier im Bereich vereinheitlichter Datenmanagementlösungen, hat die Einführung seines Copiloten angekündigt, eines fortschrittlichen KI-gesteuerten Instruments, das Unternehmen nahtlose, datengesteuerte Entscheidungsfindungsfunktionen bietet. Copilot von Decube soll die Artwork und Weise verändern, wie Unternehmen mit ihren Daten interagieren und sie nutzen, und sie zugänglicher, umsetzbarer und aufschlussreicher machen.

Die Fähigkeit, schnell fundierte Entscheidungen zu treffen, ist im heutigen schnelllebigen Geschäftsumfeld von entscheidender Bedeutung. Copilot von Decube geht auf dieses Downside ein, indem es einen KI-Assistenten bietet, der sich nahtlos in vorhandene Dateninfrastrukturen integrieren lässt. Das Instrument soll Benutzern helfen, durch komplexe Datensätze zu navigieren, Erkenntnisse in Echtzeit zu generieren und Datenprozesse zu automatisieren, was letztlich zu besseren Geschäftsergebnissen führt.

„Wir bei Decube glauben, dass Daten das Herzstück jeder erfolgreichen Geschäftsstrategie sind“, sagte Jatin Solanki, Mitbegründer und CEO von Decube. „Mit der Einführung von Decubes Copilot machen wir einen bedeutenden Schritt in Richtung Demokratisierung des Zugangs zu leistungsstarken Dateneinblicken und ermöglichen es Unternehmen jeder Größe, das volle Potenzial ihrer Daten einfach und effizient auszuschöpfen.“

Copilot ist mit Funktionen ausgestattet, die es Benutzern ermöglichen, Fragen in natürlicher Sprache zu stellen und sofort relevante Antworten zu erhalten. Dadurch wird die Dateninteraktion auch für nicht-technische Benutzer intuitiv. Darüber hinaus verbessert das Instrument die Zusammenarbeit, indem es umsetzbare Erkenntnisse liefert, die Groups problemlos teilen und in ihre Entscheidungsprozesse integrieren können.

Copilot baut auf der Suite von Datenmanagementlösungen von Decube auf, zu der auch die einheitliche Information Belief-Plattform gehört. Dieses Ökosystem umfasst Instruments für Datenbeobachtung, -ermittlung und -verwaltung, die darauf ausgelegt sind, Daten zuverlässig und auffindbar zu machen. Durch die nahtlose Integration mit den bestehenden Angeboten von Decube verbessert Copilot die Fähigkeit des Unternehmens, Finish-to-Finish-Datenmanagementlösungen bereitzustellen, die das gesamte Spektrum moderner Unternehmensdatenanforderungen abdecken – von der Gewährleistung der Datenqualität und -zuverlässigkeit bis hin zur Ermöglichung KI-gestützter Erkenntnisse und Entscheidungsfindung.

Melden Sie sich für die kostenlosen insideAI Information an Publication.

Folgen Sie uns auf Twitter: https://twitter.com/InsideBigData1

Folgen Sie uns auf LinkedIn: https://www.linkedin.com/firm/insideainews/

Folgen Sie uns auf Fb: https://www.fb.com/insideAINEWSNOW