semantische – chatgpz.de – KI-Tools & Praxiswissen

Wie maschinelles Lernen und semantische Einbettungen CVE-Schwachstellen über rohe CVSS-Ergebnisse hinaus neu ordnen

admin — Sat, 24 Jan 2026 13:43:06 +0000

[ad_1]

def visualize_results(df, priority_scores, feature_importance):
   fig, axes = plt.subplots(2, 3, figsize=(18, 10))
   fig.suptitle('Vulnerability Scanner - ML Evaluation Dashboard', fontsize=16, fontweight="daring")
   axes(0, 0).hist(priority_scores, bins=30, coloration="crimson", alpha=0.7, edgecolor="black")
   axes(0, 0).set_xlabel('Precedence Rating')
   axes(0, 0).set_ylabel('Frequency')
   axes(0, 0).set_title('Precedence Rating Distribution')
   axes(0, 0).axvline(np.percentile(priority_scores, 75), coloration="orange", linestyle="--", label="seventy fifth percentile")
   axes(0, 0).legend()
   axes(0, 1).scatter(df('cvss_score'), priority_scores, alpha=0.6, c=priority_scores, cmap='RdYlGn_r', s=50)
   axes(0, 1).set_xlabel('CVSS Rating')
   axes(0, 1).set_ylabel('ML Precedence Rating')
   axes(0, 1).set_title('CVSS vs ML Precedence')
   axes(0, 1).plot((0, 10), (0, 1), 'k--', alpha=0.3)
   severity_counts = df('severity').value_counts()
   colours = {'CRITICAL': 'darkred', 'HIGH': 'crimson', 'MEDIUM': 'orange', 'LOW': 'yellow'}
   axes(0, 2).bar(severity_counts.index, severity_counts.values, coloration=(colours.get(s, 'grey') for s in severity_counts.index))
   axes(0, 2).set_xlabel('Severity')
   axes(0, 2).set_ylabel('Depend')
   axes(0, 2).set_title('Severity Distribution')
   axes(0, 2).tick_params(axis="x", rotation=45)
   top_features = feature_importance.head(10)
   axes(1, 0).barh(top_features('function'), top_features('significance'), coloration="steelblue")
   axes(1, 0).set_xlabel('Significance')
   axes(1, 0).set_title('Prime 10 Characteristic Significance')
   axes(1, 0).invert_yaxis()
   if 'cluster' in df.columns:
       cluster_counts = df('cluster').value_counts().sort_index()
       axes(1, 1).bar(cluster_counts.index, cluster_counts.values, coloration="teal", alpha=0.7)
       axes(1, 1).set_xlabel('Cluster')
       axes(1, 1).set_ylabel('Depend')
       axes(1, 1).set_title('Vulnerability Clusters')
   attack_vector_counts = df('attack_vector').value_counts()
   axes(1, 2).pie(attack_vector_counts.values, labels=attack_vector_counts.index, autopct="%1.1f%%", startangle=90)
   axes(1, 2).set_title('Assault Vector Distribution')
   plt.tight_layout()
   plt.present()


def primary():
   print("="*70)
   print("AI-ASSISTED VULNERABILITY SCANNER WITH ML PRIORITIZATION")
   print("="*70)
   print()
   fetcher = CVEDataFetcher()
   df = fetcher.fetch_recent_cves(days=30, max_results=50)
   print(f"Dataset Overview:")
   print(f"  Whole CVEs: {len(df)}")
   print(f"  Date Vary: {df('printed').min()(:10)} to {df('printed').max()(:10)}")
   print(f"  Severity Breakdown: {df('severity').value_counts().to_dict()}")
   print()
   feature_extractor = VulnerabilityFeatureExtractor()
   embeddings = feature_extractor.extract_semantic_features(df('description').tolist())
   df = feature_extractor.extract_keyword_features(df)
   df = feature_extractor.encode_categorical_features(df)
   prioritizer = VulnerabilityPrioritizer()
   X = prioritizer.prepare_features(df, embeddings)
   severity_map = {'LOW': 0, 'MEDIUM': 1, 'HIGH': 2, 'CRITICAL': 3, 'UNKNOWN': 1}
   y_severity = df('severity').map(severity_map).values
   y_score = df('cvss_score').values
   X_scaled = prioritizer.train_models(X, y_severity, y_score)
   priority_scores, severity_probs, score_preds = prioritizer.predict_priority(X)
   df('ml_priority_score') = priority_scores
   df('predicted_score') = score_preds
   analyzer = VulnerabilityAnalyzer(n_clusters=5)
   clusters = analyzer.cluster_vulnerabilities(embeddings)
   df = analyzer.analyze_clusters(df, clusters)
   feature_imp, emb_imp = prioritizer.get_feature_importance()
   print(f"n--- Characteristic Significance ---")
   print(feature_imp.head(10))
   print(f"nAverage embedding significance: {emb_imp:.4f}")
   print("n" + "="*70)
   print("TOP 10 PRIORITY VULNERABILITIES")
   print("="*70)
   top_vulns = df.nlargest(10, 'ml_priority_score')(('cve_id', 'cvss_score', 'ml_priority_score', 'severity', 'description'))
   for idx, row in top_vulns.iterrows():
       print(f"n{row('cve_id')} (Precedence: {row('ml_priority_score'):.3f})")
       print(f"  CVSS: {row('cvss_score'):.1f} | Severity: {row('severity')}")
       print(f"  {row('description')(:100)}...")
   print("nnGenerating visualizations...")
   visualize_results(df, priority_scores, feature_imp)
   print("n" + "="*70)
   print("ANALYSIS COMPLETE")
   print("="*70)
   print(f"nResults abstract:")
   print(f"  Excessive Precedence (>0.7): {(priority_scores > 0.7).sum()} vulnerabilities")
   print(f"  Medium Precedence (0.4-0.7): {((priority_scores >= 0.4) & (priority_scores <= 0.7)).sum()}")
   print(f"  Low Precedence (<0.4): {(priority_scores < 0.4).sum()}")
   return df, prioritizer, analyzer


if __name__ == "__main__":
   results_df, prioritizer, analyzer = primary()
   print("n✓ All analyses accomplished efficiently!")
   print("nYou can now:")
   print("  - Entry outcomes through 'results_df' DataFrame")
   print("  - Use 'prioritizer' to foretell new vulnerabilities")
   print("  - Discover 'analyzer' for clustering insights")

[ad_2]

So bauen Sie eine speichergestützte Agenten-KI auf, die kontinuierlich durch episodische Erfahrungen und semantische Muster lernt, um langfristige Autonomie zu gewährleisten

admin — Mon, 17 Nov 2025 17:45:23 +0000

[ad_1]

In diesem Tutorial untersuchen wir, wie man Agentensysteme aufbaut, die über eine einzelne Interaktion hinausdenken, indem Speicher als Kernfunktion genutzt wird. Wir gehen durch, wie wir das episodische Gedächtnis zum Speichern von Erfahrungen und das semantische Gedächtnis zum Erfassen langfristiger Muster entwerfen, sodass der Agent sein Verhalten über mehrere Sitzungen hinweg weiterentwickeln kann. Während wir planen, handeln, überarbeiten und reflektieren, beobachten wir, wie sich der Agent allmählich an die Präferenzen des Benutzers anpasst und autonomer wird. Am Ende verstehen wir, wie gedächtnisgesteuertes Denken uns hilft, Agenten zu schaffen, die sich bei jeder Interaktion kontextbezogener, konsistenter und intelligenter anfühlen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

import numpy as np
from collections import defaultdict
import json
from datetime import datetime
import pickle


class EpisodicMemory:
   def __init__(self, capability=100):
       self.capability = capability
       self.episodes = ()
      
   def retailer(self, state, motion, consequence, timestamp=None):
       if timestamp is None:
           timestamp = datetime.now().isoformat()
       episode = {
           'state': state,
           'motion': motion,
           'consequence': consequence,
           'timestamp': timestamp,
           'embedding': self._embed(state, motion, consequence)
       }
       self.episodes.append(episode)
       if len(self.episodes) > self.capability:
           self.episodes.pop(0)
  
   def _embed(self, state, motion, consequence):
       textual content = f"{state} {motion} {consequence}".decrease()
       return hash(textual content) % 10000
  
   def retrieve_similar(self, query_state, ok=3):
       if not self.episodes:
           return ()
       query_emb = self._embed(query_state, "", "")
       scores = ((abs(ep('embedding') - query_emb), ep) for ep in self.episodes)
       scores.kind(key=lambda x: x(0))
       return (ep for _, ep in scores(:ok))
  
   def get_recent(self, n=5):
       return self.episodes(-n:)


class SemanticMemory:
   def __init__(self):
       self.preferences = defaultdict(float)
       self.patterns = defaultdict(checklist)
       self.success_rates = defaultdict(lambda: {'success': 0, 'whole': 0})
      
   def update_preference(self, key, worth, weight=1.0):
       self.preferences(key) = 0.9 * self.preferences(key) + 0.1 * weight * worth
  
   def record_pattern(self, context, motion, success):
       pattern_key = f"{context}_{motion}"
       self.patterns(context).append((motion, success))
       self.success_rates(pattern_key)('whole') += 1
       if success:
           self.success_rates(pattern_key)('success') += 1
  
   def get_best_action(self, context):
       if context not in self.patterns:
           return None
       action_scores = defaultdict(lambda: {'success': 0, 'whole': 0})
       for motion, success in self.patterns(context):
           action_scores(motion)('whole') += 1
           if success:
               action_scores(motion)('success') += 1
       best_action = max(action_scores.gadgets(), key=lambda x: x(1)('success') / max(x(1)('whole'), 1))
       return best_action(0) if best_action(1)('whole') > 0 else None
  
   def get_preference(self, key):
       return self.preferences.get(key, 0.0)

Wir definieren die Kernspeicherstrukturen, auf die sich unser Agent verlässt. Wir bauen ein episodisches Gedächtnis auf, um spezifische Erfahrungen zu erfassen, und ein semantisches Gedächtnis, um Muster im Laufe der Zeit zu verallgemeinern. Indem wir diese Grundlagen schaffen, bereiten wir den Agenten darauf vor, aus Interaktionen zu lernen, so wie es Menschen tun. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class MemoryAgent:
   def __init__(self):
       self.episodic_memory = EpisodicMemory(capability=50)
       self.semantic_memory = SemanticMemory()
       self.current_plan = ()
       self.session_count = 0
      
   def understand(self, user_input):
       user_input = user_input.decrease()
       if any(phrase in user_input for phrase in ('suggest', 'recommend', 'what ought to')):
           intent="advice"
       elif any(phrase in user_input for phrase in ('bear in mind', 'favor', 'like', 'favourite')):
           intent="preference_update"
       elif any(phrase in user_input for phrase in ('do', 'full', 'end', 'activity')):
           intent="task_execution"
       else:
           intent="dialog"
       return {'intent': intent, 'uncooked': user_input}
  
   def plan(self, state):
       intent = state('intent')
       user_input = state('uncooked')
       similar_episodes = self.episodic_memory.retrieve_similar(user_input, ok=3)
       plan = ()
       if intent == 'advice':
           genre_prefs = {ok: v for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok}
           if genre_prefs:
               best_genre = max(genre_prefs.gadgets(), key=lambda x: x(1))(0)
               plan.append(('suggest', best_genre.exchange('genre_', '')))
           else:
               plan.append(('suggest', 'normal'))
       elif intent == 'preference_update':
           genres = ('sci-fi', 'fantasy', 'thriller', 'romance', 'thriller')
           detected_genre = subsequent((g for g in genres if g in user_input), None)
           if detected_genre:
               plan.append(('update_preference', detected_genre))
       elif intent == 'task_execution':
           best_action = self.semantic_memory.get_best_action('activity')
           if best_action:
               plan.append(('execute', best_action))
           else:
               plan.append(('execute', 'default'))
       self.current_plan = plan
       return plan

Wir konstruieren die Wahrnehmungs- und Planungssysteme des Agenten. Wir verarbeiten die Eingaben des Benutzers, erkennen Absichten und erstellen Pläne, indem wir die zuvor gebildeten Erinnerungen nutzen. Wir beginnen zu gestalten, wie der Agent seine nächsten Aktionen begründet und entscheidet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def act(self, motion):
       action_type, param = motion
       if action_type == 'suggest':
           if param == 'normal':
               return f"Let me be taught your preferences first! What genres do you get pleasure from?"
           return f"Based mostly in your preferences, I like to recommend exploring {param}!"
       elif action_type == 'update_preference':
           self.semantic_memory.update_preference(f'genre_{param}', 1.0, weight=1.0)
           return f"Received it! I am going to bear in mind you get pleasure from {param}."
       elif action_type == 'execute':
           return f"Executing activity with technique: {param}"
       return "Motion accomplished"
  
   def revise_plan(self, suggestions):
       if 'no' in suggestions.decrease() or 'incorrect' in suggestions.decrease():
           if self.current_plan:
               action_type, param = self.current_plan(0)
               if action_type == 'suggest':
                   genre_prefs = sorted(
                       ((ok, v) for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok),
                       key=lambda x: x(1),
                       reverse=True
                   )
                   if len(genre_prefs) > 1:
                       new_genre = genre_prefs(1)(0).exchange('genre_', '')
                       self.current_plan = (('suggest', new_genre))
                       return True
       return False
  
   def replicate(self, state, motion, consequence, success):
       self.episodic_memory.retailer(state('uncooked'), str(motion), consequence)
       self.semantic_memory.record_pattern(state('intent'), str(motion), success)

Wir definieren, wie der Agent Aktionen ausführt, seine Entscheidungen revidiert, wenn das Suggestions den Erwartungen widerspricht, und wie er durch die Speicherung von Erfahrungen reflektiert. Wir verbessern kontinuierlich das Verhalten des Agenten, indem wir ihn aus jeder Runde lernen lassen. Durch diese Schleife machen wir das System anpassungsfähig und selbstkorrigierend. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def run_session(self, user_inputs):
       self.session_count += 1
       print(f"n{'='*60}")
       print(f"SESSION {self.session_count}")
       print(f"{'='*60}n")
       outcomes = ()
       for i, user_input in enumerate(user_inputs, 1):
           print(f"Flip {i}")
           print(f"Person: {user_input}")
           state = self.understand(user_input)
           plan = self.plan(state)
           if not plan:
               print("Agent: I am unsure what to do with that.n")
               proceed
           response = self.act(plan(0))
           print(f"Agent: {response}n")
           success="suggest" in plan(0)(0) or 'replace' in plan(0)(0)
           self.replicate(state, plan(0), response, success)
           outcomes.append({
               'flip': i,
               'enter': user_input,
               'intent': state('intent'),
               'motion': plan(0),
               'response': response
           })
       return outcomes

Wir simulieren reale Interaktionen, bei denen der Agent mehrere Benutzereingaben innerhalb einer einzigen Sitzung verarbeitet. Wir beobachten, wie sich der Zyklus Wahrnehmen → Planen → Handeln → Reflektieren immer wieder entfaltet. Während wir Sitzungen durchführen, sehen wir, wie der Agent nach und nach personalisierter und intelligenter wird. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def evaluate_memory_usage(agent):
   print("n" + "="*60)
   print("MEMORY ANALYSIS")
   print("="*60 + "n")
   print(f"Episodic Reminiscence:")
   print(f"  Complete episodes saved: {len(agent.episodic_memory.episodes)}")
   if agent.episodic_memory.episodes:
       print(f"  Oldest episode: {agent.episodic_memory.episodes(0)('timestamp')}")
       print(f"  Newest episode: {agent.episodic_memory.episodes(-1)('timestamp')}")
   print(f"nSemantic Reminiscence:")
   print(f"  Discovered preferences: {len(agent.semantic_memory.preferences)}")
   for pref, worth in sorted(agent.semantic_memory.preferences.gadgets(), key=lambda x: x(1), reverse=True)(:5):
       print(f"    {pref}: {worth:.3f}")
   print(f"n  Motion patterns discovered: {len(agent.semantic_memory.patterns)}")
   print(f"n  Success charges by context-action:")
   for key, stats in checklist(agent.semantic_memory.success_rates.gadgets())(:5):
       if stats('whole') > 0:
           charge = stats('success') / stats('whole')
           print(f"    {key}: {charge:.2%} ({stats('success')}/{stats('whole')})")


def compare_sessions(results_history):
   print("n" + "="*60)
   print("CROSS-SESSION ANALYSIS")
   print("="*60 + "n")
   for i, ends in enumerate(results_history, 1):
       recommendation_quality = sum(1 for r in outcomes if 'preferences' in r('response').decrease())
       print(f"Session {i}:")
       print(f"  Turns: {len(outcomes)}")
       print(f"  Customized responses: {recommendation_quality}")

Wir analysieren, wie effektiv der Agent seine Erinnerungen nutzt. Wir überprüfen gespeicherte Episoden, erlernte Präferenzen und Erfolgsmuster, um zu bewerten, wie sich der Agent entwickelt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def run_demo():
   agent = MemoryAgent()
   print("n SCENARIO: Agent learns consumer preferences over a number of periods")
   session1_inputs = (
       "Hello, I am searching for one thing to learn",
       "I actually like sci-fi books",
       "Are you able to suggest one thing?",
   )
   results1 = agent.run_session(session1_inputs)
   session2_inputs = (
       "I am bored, what ought to I learn?",
       "Really, I additionally get pleasure from fantasy novels",
       "Give me a advice",
   )
   results2 = agent.run_session(session2_inputs)
   session3_inputs = (
       "What do you recommend for tonight?",
       "I am within the temper for thriller too",
       "Advocate one thing primarily based on what you recognize about me",
   )
   results3 = agent.run_session(session3_inputs)
   evaluate_memory_usage(agent)
   compare_sessions((results1, results2, results3))
   print("n" + "="*60)
   print("EPISODIC MEMORY RETRIEVAL TEST")
   print("="*60 + "n")
   question = "suggest sci-fi"
   comparable = agent.episodic_memory.retrieve_similar(question, ok=3)
   print(f"Question: '{question}'")
   print(f"Retrieved {len(comparable)} comparable episodes:n")
   for ep in comparable:
       print(f"  State: {ep('state')}")
       print(f"  Motion: {ep('motion')}")
       print(f"  Final result: {ep('consequence')(:50)}...")
       print()


if __name__ == "__main__":
   print("="*60)
   print("MEMORY & LONG-TERM AUTONOMY IN AGENTIC SYSTEMS")
   print("="*60)
   run_demo()
   print("n Tutorial full! Key takeaways:")
   print("  • Episodic reminiscence shops particular experiences")
   print("  • Semantic reminiscence generalizes patterns")
   print("  • Brokers enhance suggestions over periods")
   print("  • Reminiscence retrieval guides future choices")

Wir bringen alles zusammen, indem wir mehrere Sitzungen durchführen und den Speicherabruf testen. Wir beobachten, wie sich der Agent über Interaktionen hinweg verbessert und verfeinern Empfehlungen auf der Grundlage des gesammelten Wissens. Diese umfassende Demo veranschaulicht, wie sich aus den von uns entwickelten Speichersystemen auf natürliche Weise langfristige Autonomie ergibt.

Zusammenfassend erkennen wir, wie die Kombination aus episodischem und semantischem Gedächtnis es uns ermöglicht, Agenten zu entwickeln, die kontinuierlich lernen und im Laufe der Zeit immer bessere Entscheidungen treffen. Wir beobachten, wie der Agent Empfehlungen verfeinert, Pläne anpasst und vergangene Erfahrungen abruft, um seine Reaktionen Sitzung für Sitzung zu verbessern. Durch diese Mechanismen sehen wir, wie aus einfachen, aber effektiven Gedächtnisstrukturen langfristige Autonomie entsteht.

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 Publication. 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.

[ad_2]

Ausrichtung: Differenzierbare, semantische Bildregistrierung mit Kornia

admin — Tue, 21 May 2024 11:38:46 +0000

[ad_1]

Ich habe Anfang des Jahres ein Type bekommen.

Warten Sie, um Applaus zu erhalten

Na ja, nicht ich persönlich, aber meine Frau schon.

Ich erzähle Ihnen das nur, um Ihnen zu sagen, dass ich jede Woche ein Foto von meiner Frau gemacht habe, als sie schwanger conflict.

Wir dachten, es wäre vielleicht interessant, eines Tages noch einmal auf diese Bilder zurückzublicken. Sie trug das gleiche Outfit und blickte bei jedem Bild in die gleiche Richtung, obwohl sich der Hintergrund gelegentlich änderte. Um den Dingen in meinem Leben weniger neurotisch gegenüberzustehen, habe ich bewusst auf ein Stativ verzichtet und auch nicht versucht, das Bild aus genau demselben Winkel und derselben Entfernung aufzunehmen.

Am Ende wurde ein Type geboren und ich vergaß die besagten Bilder sofort, denn wen interessieren solche Dinge um 4 Uhr morgens?

Nun, es ist einige Zeit vergangen und das Type schläft die ganze Nacht durch.

Warten Sie, um Applaus zu erhalten

Ich habe jetzt etwas Freizeit und dachte, es wäre cool, eine Animation dieser Schwangerschaftsbilder zu machen. Angesichts meiner fotografischen Unvollkommenheit musste ich die Bilder für die Animation zuschneiden, drehen und ausrichten. Natürlich wollte ich das nicht manuell machen. Wie lange könnte es dauern, automatisieren?

…

Offensichtlich hat die Automatisierung viel länger gedauert als die manuelle Durchführung, aber jetzt kann ich darüber sprechen, wie ich dieses Video mithilfe der differenzierbaren, semantischen Bildregistrierung mit Kornia erstellt habe.

Hinweis: Wie die meisten meiner Blogbeiträge habe ich auch diesen in einem Jupiter-Notizbuch geschrieben. Ich werde auf ein Paket namens verweisen Ausrichtung im Code. Dies ist nur eine kleine Bibliothek, die ich erstellt habe, um meinen Code unterzubringen und diesen Weblog-Beitrag lesbarer zu machen.

Fototermine

Um das vorliegende Drawback zu verstehen, schauen wir uns zwei verschiedene Bilder an, die ich ausrichten möchte:

%config InlineBackend.figure_format = 'retina'

from pathlib import Path

import alignimation
import kornia as Okay
import matplotlib.pyplot as plt
import torch
import torch.nn.practical as F

imgs = alignimation.io.load_images(Path("body_pics"))

fig, axs = plt.subplots(1, 2)
axs(0).imshow(Okay.tensor_to_image(imgs(0)))
axs(1).imshow(Okay.tensor_to_image(imgs(22)))
axs(0).axis("off")
axs(1).axis("off")
fig.tight_layout()
None

Das Ziel hier ist, beide Bilder so zu verändern, dass die Körper vorhanden sind Eingetragen miteinander. Man könnte sich mehrere verschiedene vorstellen Operationen Das könnte man am Bild tun, um dies zu erreichen: Man kann das Bild in eine Richtung verschieben, man kann hinein- oder herauszoomen und man kann das Bild drehen. (Sie könnten auch andere believable Dinge tun, wie zum Beispiel das Bild scheren, aber wir werden diese Vorgänge ignorieren.)

Ein Bild ist eine 3D-Matrix (oder Tensor in modernen Begriffen). Für jedes Pixel gibt es eine Höhen- und Breitendimension und dann drei Kanaldimensionen (Rot, Grün und Blau).

print(kind(imgs(0)))
print(imgs(0).form)


torch.Dimension((1, 3, 4032, 3024))

In der Welt der linearen Algebra sind die Operationen, die wir gerne durchführen würden, bekannte Matrixtransformationen: Translation, Skalierung und Rotation. Diese können rein in durchgeführt werden numpy oder mit einer Vielzahl anderer Bibliotheken.

Großartig, wir können herausfinden, wie wir die Bilder transformieren, aber wie stark transformieren wir jedes Bild?

Differenzierung durch Differenzierung

Vor ein paar Jahren habe ich eine gegeben sprechen bei SciPy über alle Gründe, warum Deep-Studying-Frameworks spannend sind, wenn es nicht um Deep Studying geht. Einer dieser Gründe ist die automatische Differenzierung: Solange Sie Ihr „Modell“ mithilfe des Deep-Studying-Frameworks ausdrücken können, können Sie alle Arten von Zielfunktionen optimieren, ohne Kalküle schreiben zu müssen.

Wenn ich kann, komme ich noch einmal auf unser Drawback mit der automatischen Bildregistrierung zurück

Definieren Sie meine Bildtransformationen mithilfe eines Deep-Studying-Frameworks
Überlegen Sie sich eine Zielfunktion, die beschreibt, wie registriert zwei Bilder sind

Dann kann ich diese Zielfunktion optimieren, um die optimalen Bildtransformationsparameter zu finden.

Gegen Ende meines Vortrags erwähnte ich, dass es großartig wäre, wenn wir alle möglichen Spezialbibliotheken auf der Foundation von Deep-Studying-Frameworks neu aufbauen würden, um neben der automatischen Differenzierung auch alle möglichen anderen Dinge wie eine Beschleunigung der GPU nutzen zu können.

Kornia ist genau eine dieser Bibliotheken, von denen ich gehofft hatte, dass sie gebaut werden würden. kornia bietet viele der Funktionen „klassischer“ Pc-Imaginative and prescient-Bibliotheken wie OpenCV und das MATLAB Bildverarbeitungs-Toolboxaber es ist darauf aufgebaut PyTorch. Entscheidend sind alle Bildtransformationen in kornia sind differenzierbare PyTorch-Module.

Was ist das Ziel?

Eine einfache zu optimierende Zielfunktion wäre die absolute (L1) Differenz zwischen jedem Pixel zweier verschiedener Bilder. Bei der Ausrichtung der Bilder hätten die Pixel vermutlich ähnliche Werte. Somit könnten wir diese Zielfunktion minimieren.

Während ich an diesem Projekt arbeitete, erschien eine neue Model von kornia wurde veröffentlicht, das genau dafür eine Funktionalität hatte: das ImageRegistrator Modul lernt ein Modell für Bildtransformationen, um den L1-Verlust zwischen zwei Bildern zu minimieren.

Während dies für meinen Anwendungsfall funktionieren könnte, hatte ich Angst, dass der Hintergrund meiner Bilder die Optimierung der Ausrichtung meiner Frau beeinträchtigen würde. Zum Glück können wir PyTorch verwenden, da wir es bereits verwenden Fackelvision um den Körper in einem Bild leicht zu erkennen.

from torchvision.fashions.detection import maskrcnn_resnet50_fpn

segmentation_model = maskrcnn_resnet50_fpn(
    pretrained=True, progress=False
)
segmentation_model = segmentation_model.eval()
person_index = (
    alignimation.constants.COCO_INSTANCE_CATEGORY_NAMES.index("individual")
)
masks = alignimation.base.get_segmentation_masks(
    torch.cat((imgs(0), imgs(22))), 
    segmentation_model, 
    "cpu", 
    person_index
)

fig, axs = plt.subplots(1, 2)
axs(0).imshow(Okay.tensor_to_image(imgs(0)))
axs(1).imshow(
    Okay.tensor_to_image(masks(0)), cmap=plt.get_cmap("turbo")
)
axs(0).axis("off")
axs(1).axis("off")
fig.tight_layout()
None

Da wir nun den Körper auswählen können, lautet das Rezept:

Erstellen Sie die „Segmentierungsmaske“, die dem Körper im Bild entspricht.
Passen Sie an ImageRegistrator um die Segmentierungsmasken auszurichten.
Nutzen Sie das Geschulte ImageRegistrator um das tatsächliche Bild zu registrieren.

Erinnern Sie sich, als ich sagte, ich versuche, weniger neurotisch zu sein? Leider ging das alles verloren, als ich anfing, Code zu schreiben. Ich befürchtete, dass die Veränderung des Körpers meiner Frau die Ausrichtung der Segmentierungsmaske beeinflussen würde, da der Schwerpunkt nach hyperlinks verschoben wird – ich meine, wenn das Child wächst. Außerdem sind die Haare meiner Frau manchmal nach oben und manchmal nach unten gerichtet, und die Segmentierungsmaske umfasst die Haare.

Wie richtet man nur den Körper und weder das Child noch die Haare aus? Wieder, torchvision zur Rettung. Verwendung einer Kernpunkt Modell können wir das linke Ohr, die Schulter und die Hüfte erkennen.

from torchvision.fashions.detection import keypointrcnn_resnet50_fpn

keypoint_model = keypointrcnn_resnet50_fpn(
    pretrained=True, progress=False
)
keypoint_model = keypoint_model.eval()
keypoint_names = ("left_ear", "left_shoulder", "left_hip")
keypoint_indices = (
    alignimation.constants.BODY_KEYPOINT_NAMES.index(ok) 
    for ok in keypoint_names
)
keypoints = alignimation.base.get_keypoints(
    keypoint_model, 
    torch.cat((imgs(0), imgs(22))), 
    "cpu", 
    1, 
    keypoint_indices
)

fig, axs = plt.subplots(1, 2)
axs(0).imshow(Okay.tensor_to_image(imgs(0)))
axs(0).scatter(
    x=keypoints(0, :, 0),
    y=keypoints(0, :, 1),
    s=30,
    marker="o",
    coloration="purple",
)
axs(1).imshow(Okay.tensor_to_image(imgs(22)))
axs(1).scatter(
    x=keypoints(1, :, 0),
    y=keypoints(1, :, 1),
    s=30,
    marker="o",
    coloration="purple",
)
axs(0).axis("off")
axs(1).axis("off")
fig.tight_layout()
None

Es kann schwierig sein, die Registrierung von drei einzelnen Punkten zu optimieren. Lassen Sie uns additionally zwischen der Segmentierungsmaske und den Schlüsselpunkten interpolieren: Ich werde 2D-Gauß-Funktionen um jeden Schlüsselpunkt erstellen und diese dann mit der Segmentierungsmaske multiplizieren. Dies alles sollte für eine schöne, reibungslose Optimierung sorgen.

gaussians = alignimation.base.make_keypoint_gaussians(
    keypoints, imgs(0).form(-2:)
)
gaussian_masks = masks * gaussians

fig, axs = plt.subplots(1, 2)
axs(0).imshow(
    Okay.tensor_to_image(gaussian_masks(0).sum(dim=0, keepdim=True)),
    cmap=plt.get_cmap("turbo"),
)
axs(1).imshow(
    Okay.tensor_to_image(gaussian_masks(1).sum(dim=0, keepdim=True)),
    cmap=plt.get_cmap("turbo"),
)
axs(0).axis("off")
axs(1).axis("off")
fig.tight_layout()
None

Jetzt müssen nur noch die beiden Masken endlich miteinander registriert werden. Im Einklang mit unserer Richtlinie zur reibungslosen Optimierung verwenden wir einen L2-Verlust.

registrator = Okay.geometry.ImageRegistrator(
    "similarity", tolerance=1e-8, loss_fn=F.mse_loss
)

_ = registrator.register(gaussian_masks((1)), gaussian_masks((0)))

Nachdem das Modell zur Registrierung der beiden Masken angepasst wurde, kann es zur Registrierung der beiden Bilder verwendet werden.

with torch.inference_mode():
    aligned_mask = registrator.warp_src_into_dst(gaussian_masks((1)))
    aligned_img = registrator.warp_src_into_dst(imgs(22))

fig, axs = plt.subplots(2, 2, figsize=(6, 8))
axs = axs.flatten()
axs(0).imshow(
    Okay.tensor_to_image(gaussian_masks(0).sum(dim=0, keepdim=True)),
    cmap=plt.get_cmap("turbo"),
)
axs(1).imshow(
    Okay.tensor_to_image(aligned_mask(0).sum(dim=0, keepdim=True)),
    cmap=plt.get_cmap("turbo"),
)
axs(2).imshow(Okay.tensor_to_image(imgs(0)))
axs(3).imshow(Okay.tensor_to_image(aligned_img))
for ax in axs:
    ax.axis("off")
fig.tight_layout()
None

Hurra! Um die „Ausrichtung“ oben in diesem Beitrag vorzunehmen, habe ich für alle meine Fotos das oben beschriebene Verfahren befolgt.

Als Bonus kann ich, da ich bereits die Körpersegmentierungsmaske hatte, den Hintergrund hackenartig entfernen:

Flüchtige Jugend

Während ich daran arbeitete, wurde mir klar, dass dieser Code für jedes Szenario wiederverwendet werden kann, in dem man eine Reihe von Schlüsselpunkten oder Segmentierungsmasken ausrichten möchte. Auch wenn es sehr gruselig und überwachungsmäßig ist, könnte man wichtige Gesichtspunkte heraussuchen und eine Reihe von Bildern derselben Particular person aneinanderreihen.

Apropos Überwachung: Ich speichere alle meine Fotos in Google Fotos. Ich habe nicht nur Bilder gespeichert, die ich mit meinem Telefon aufgenommen habe, sondern auch eine Reihe alter digitaler Bilder hochgeladen, die etwa aus dem Jahr 2000 stammen.

Eine alarmierende, aber praktische Funktion von Google Fotos besteht darin, dass es automatisch die Gesichter verschiedener Personen in Ihren Bildern erkennt und Alben erstellt, die nur Bilder dieser Particular person enthalten. Der Algorithmus ist überraschend intestine und konnte mir durch die Zeit und um Haaresbreite folgen.

Ich habe mehr als 1.000 Bilder von mir heruntergeladen, die 20 Jahre zurückblicken, und beschloss, eine Animation zu erstellen, in der ich mich im Laufe der Jahre altern lasse. Wie üblich erwies sich diese geringfügige Variation der oben genannten Ausrichtungsaufgabe als mehr als nur geringfügig kompliziert.

Gesichtsbewusstsein

Der Vorgang zum Ausrichten meines Gesichts ähnelt dem vorherigen Vorgang:

Suchen Sie auf den Bildern nach meinem Gesicht
Wählen Sie Gesichtsschwerpunkte aus.
Erstellen Sie 2D-Gauß-Masken um die Gesichtsschwerpunkte.
Registrieren Sie die Gaußschen Masken und transformieren Sie dann das Originalbild.

Da es sich jedoch um Bilder „in freier Wildbahn“ handelte und nicht um Bilder, die ich explizit auf die gleiche Weise aufgenommen hatte, waren die ersten beiden Schritte aufwändiger.

Auffällig fehlt in torchvision Gibt es vorab trainierte Modelle zur Erkennung von Gesichtern oder Gesichts-Schlüsselpunkten (ich gehe davon aus, dass dies Absicht ist?). Stattdessen habe ich verwendet Facenet-Pytorch um alle Gesichter in jedem Bild zu erkennen. Jedes erkannte Gesicht erhält einen Begrenzungsrahmen und eine Reihe von Gesichts-„Landmarken“ (auch Schlüsselpunkte genannt), die beiden Augen, der Nase und beiden Lippenwinkeln entsprechen.

Mit diesem Device in meiner Toolbox sah mein Prozess dann so aus:

Erkennen Sie alle Gesichter in allen Bildern.
Markieren Sie auf jedem Bild mein Gesicht.
Wählen Sie meine wichtigsten Gesichtspunkte aus.
Werfen Sie Bilder weg, bei denen ich nicht nach vorne schaue.

Ich habe mein Gesicht im Bild ausgewählt, indem ich zunächst mithilfe der letzten Ebene eines vorab trainierten Modells Einbettungen für alle erkannten Gesichter in allen Bildern erstellt habe. Anschließend habe ich eine Einbettung erstellt, um mich selbst darzustellen, indem ich den Durchschnitt aller Einbettungen gebildet habe. Da ich in jedem Bild zu sehen bin, sollte ich den Durchschnitt „dominieren“. Dann schaue ich mir jedes Bild an und finde das eingebettete Gesicht, das meinem am nächsten kommt, und gehe davon aus, dass ich das bin.

Ich bestimme, ob ich nach vorne schaue, indem ich den Abstand zwischen meiner Nase und einem meiner Augen messe. Wenn ein Auge viel näher an meiner Nase ist als das andere, gehe ich davon aus, dass ich seitwärts schaue, und verwerfe das Bild. Ich überprüfe auch den Abstand zwischen meinen Lippenwinkeln und meiner Nase. Diese Heuristik schlägt fehl, wenn ich nach unten oder oben schaue.

Jetzt alle zusammen

Nachdem ich den oben beschriebenen Prozess befolgt habe, um die Schlüsselpunkte meines Gesichts aus jedem Bild zu extrahieren, kann ich die Bilder und Schlüsselpunkte dann in mein ursprüngliches Verfahren zur semantischen Bildregistrierung einspeisen und eine endgültige „Anpassung“ von zwei Jahrzehnten Ethans erhalten.

[ad_2]