דלג לתוכן הראשי

קורס מקצועי בתחום ה-AI לתעשייה

הטמעת סוכני AI בסביבת ייצור עם AWS AgentCore

קורס מעשי ללמידת פיתוח, שלוט והטמעת סוכני בינה מלאכותית בתהליכי ייצור באמצעות פלטפורמת AWS

רמה: מתקדמים
32 שעות למידה

מטרות הקורס

  • הבנה עמוקה של ארכיטקטורת AWS AgentCore ויכולותיה
  • פיתוח סוכני AI מותאמים לתהליכי ייצור וקווי ייצור
  • שלוט בזמן אמת בסוכנים והניטור של ביצועיהם
  • הטמעה בטוחה ויעילה של סוכנים בסביבה תעשייתית
1

מבוא לסוכני AI בתעשייה

3 שעות

מהם סוכני בינה מלאכותית וזקיקם בייצור

סוכן בינה מלאכותית הוא תוכנה אוטונומית שיכולה לתפוס מצב סביבתי, לקבל החלטות ולבצע פעולות בעולם הפיזי או הדיגיטלי. בסביבת ייצור, סוכנים אלו משמשים כ"עיניים וידיים" דיגיטליות המסוגלות לנטר, ניתוח והתאמת תהליכים בזמן אמת.

בעולם התעשייה 4.0, סוכנים AI משחקים תפקיד קריטי בהגברת יעילות, הפחתת פסולת, שיפור איכות וניהול מלאי חכם. הם יכולים לטפל במאות משתנים בו-זמנית, משהו שיהיה בלתי אפשרי לבני אדם לבצע ידנית.

AWS AgentCore היא הפלטפורמה המובילה בשוק להטמעה של סוכנים אלו בקנה מידה תעשייתי, עם יכולות ניטור, בקרה ואבטחה ברמה מהנדסית גבוהה.

מקרי שימוש בתעשייה 4.0

סוכנים AI משמשים בתחומים מגוונים בייצור:

  • אופטימיזציית קווי ייצור: בחירת סדרים אופטימליים, ניהול רוחק המתנה וקטנון עלויות
  • תחזוקה נבואית: ניתוח דפוסים של תקלות עתידיות על בסיס נתוני סנסור
  • בקרת איכות: זיהוי פגמים בשלב מוקדם ויציאה ממידע לתיקון תהליכים
  • ניהול אנרגיה: חיסכון בחשמל ובדלקים באמצעות תיאום חכם של תהליכים
  • לוגיסטיקה בתוך מחסנים: ניתוב רובוטים וניהול מלאי בזמן אמת

סקירת ארכיטקטורת AWS AgentCore

AWS AgentCore בנויה על ארכיטקטורה מודולרית המאפשרת קשקוש וביצוע מהיר של סוכנים:

# ארכיטקטורה בסיסית של סוכן ב-AgentCore { "agent": { "id": "agent-mfg-001", "name": "Production Line Optimizer", "version": "1.0.0", "sensors": ["temp-line1", "speed-line1", "defect-cam-1"], "actions": ["adjust-speed", "alert-operator", "stop-line"], "decision_engine": "reinforcement-learning", "update_frequency_ms": 500, "state": "ACTIVE" } }

הארכיטקטורה מורכבת משלוש שכבות עיקריות: שכבת האיסוף (Sensor Layer), שכבת ההחלטה (Decision Engine) ושכבת הביצוע (Action Layer). כל שכבה יכולה להתפעל בעצמאות ובחיבור למערכת המרכזית.

התחברות לשירותי AWS הקשורים

AgentCore משתלבת עם כלים חזקים נוספים מ-AWS לאזי מלא של סוכנים:

  • AWS IoT Core: ניהול התחברויות של מיליוני מכשירים
  • Amazon SageMaker: אימון מודלי ML להחלטות מיטביות
  • Amazon CloudWatch: ניטור רמת הדרך של סוכנים ושירותים
  • AWS Lambda: ביצוע פונקציות חישובית קל משקל
  • Amazon DynamoDB: אחסון מצב סוכן בזמן אמת

טיפ חשוב

כדי להבין סוכנים ב-AgentCore, תחשוב עליהם כ"עובדים רובוטים חכמים" שלך — כל אחד אחראי על תחום מסוים, יכול ללמוד מהעבר, ומבדיל בין מה שהוא יודע לבין מה שהוא לא יודע.

2

יסודות AWS AgentCore

4 שעות

הגדרת סביבת עבודה ב-AWS

לפני שמתחילים לפתח סוכנים, יש להקים סביבת AWS שלמה. זה כולל יצירת חשבון AWS, הגדרת תפקידי IAM, הפעלת שירותים הדרושים וקביעת מרחק אחסון בטוח לנתונים רגישים של ייצור.

מבחינה בטיחותית, חובה להשתמש בחשבון AWS ייעודי לפרויקט ייצור, להגדיר מפתחות גישה (Access Keys) בקפדנות, ולהשתמש ב-IAM roles בעלות הרשאות minimal המתאימה ל-principle of least privilege.

# הגדרת AWS CLI עם ה-region הנכון aws configure --profile manufacturing # הזן Access Key ID: AKIA... # הזן Secret Access Key: ... # region: eu-central-1 # output format: json # בדיקה של תצורה aws sts get-caller-identity --profile manufacturing

ממשקי API של AgentCore

AWS AgentCore חושפת ממשקי REST API ו-gRPC לניהול מלא של סוכנים. ה-REST API משמשת בעיקר להנהלה וקונפיגורציה, בעוד ש-gRPC משמשת לתקשורת בזמן אמת בין סוכנים.

כל API call מחייבת הזדהות דרך AWS Signature Version 4 (SigV4), שמבטיח שרק משתמשים מורשים יכולים לבקר בסוכנים ולקבל נתונים.

מבנה וחלקי סוכן

סוכן ב-AgentCore מורכב מחמישה רכיבים עיקריים:

  • Identity & Metadata: שם, מזהה ייחודי, גרסה ותאור
  • Sensors (קלט): מאיזה מקורות נתונים הוא מקבל מידע
  • Decision Engine: האלגוריתם שקובע איזו פעולה לבצע
  • Actions (פלט): אילו פעולות פיזיות או דיגיטליות ביכולתו
  • State Management: זיכרון סוכן — מה הוא זוכר מהעבר
# מבנה סוכן JSON בעת הגדרה { "metadata": { "name": "QualityControlAgent", "agent_type": "inspection", "version": "2.1.0" }, "sensors": [ { "sensor_id": "camera-defect-1", "type": "vision", "frequency_hz": 30 }, { "sensor_id": "temp-controller", "type": "thermometer", "frequency_hz": 1 } ], "actions": [ { "action_id": "reject-product", "type": "physical_stop" }, { "action_id": "alert-supervisor", "type": "notification" } ], "engine": { "type": "decision_tree", "model_arn": "arn:aws:sagemaker:..." } }

ניהול מצבי סוכן ומחזור חייו

כל סוכן עובר מחזור חיים שמתחיל בהגדרה, ממשיך להפעלה, משם לארכיון או מחיקה. לכל שלב מצבים קבועים:

  • DEFINED: סוכן הגדר אך לא הופעל
  • ACTIVE: סוכן פעיל ומבצע החלטות
  • SUSPENDED: סוכן מושהה זמנית
  • ARCHIVED: סוכן לא פעיל אך הנתונים שמור
  • DELETED: סוכן הוסר לחלוטין

המעבר בין מצבים ניתן לביצוע דרך AWS Console או דרך API. כאשר סוכן הופך ל-ACTIVE, הוא מתחיל מיד לאסוף נתונים מחיישנים ולחשוב על החלטות בהתאם לתדירות המוגדרת שלו.

ניתוח מצבים

שימו לב: כל עוד סוכן ב-ACTIVE, הוא צורך משאבים עלויות AWS. מומלץ לעבור סוכנים ל-SUSPENDED כשהם לא בשימוש, כדי לחסוך בעלויות.

3

פיתוח סוכנים ראשוניים

4.7 שעות

יצירת סוכן בסיסי עם Python/SDK

ה-AWS SDK עבור Python (boto3) מאפשרת לנו לבנות סוכנים באופן תכנותי. אתה יוצר אובייקט סוכן, מגדיר את מאפייניו, ומוציא אותו לפעולה בכמה שורות קוד בלבד.

מומלץ להשתמש בפייתון 3.9 ומעלה ול-install את boto3 דרך pip. בנוסף, צריך לעדכן את credentials ה-AWS בקובץ ~/.aws/credentials או דרך environment variables.

import boto3 import json # התחברות ל-AWS AgentCore agentcore_client = boto3.client('agentcore', region_name='eu-central-1') # הגדרת סוכן בסיסי לניטור טמפרטורה agent_config = { "name": "TemperatureMonitor", "description": "Monitors production line temperature", "sensors": [ { "id": "temp-sensor-1", "type": "temperature", "unit": "celsius" } ], "actions": [ { "id": "send-alert", "type": "notification" }, { "id": "reduce-power", "type": "control" } ], "decision_logic": { "rule": "IF temp > 85 THEN alert AND reduce-power" } } # יצירת הסוכן response = agentcore_client.create_agent( name=agent_config["name"], description=agent_config["description"], config=json.dumps(agent_config) ) print(f"Agent created: {response['agent_id']}")

הגדרת מטרות וחוקי החלטה

כל סוכן צריך להיות בעל מטרה ברורה וחוקי החלטה שמנחים אותו. מטרה יכולה להיות "הגדל את הייצור בעוד שתחזוק איכות", וחוקי החלטה הם התנאים שקובעים מתי לפעול ואיך.

חוקים אלו יכולים להיות פשוטים (IF-THEN) או מורכבים (שילובי תנאים רבים). עבור מקרים מורכבים, יש להשתמש בעצי החלטה או בעצי AI, שאומן מראש על נתוני היסטוריים.

# הגדרת חוקי החלטה מתקדמים decision_rules = { "temperature": { "target": 75, "tolerance": 5, "actions": { "below_min": "increase_heater", "above_max": "reduce_power", "normal": "maintain" } }, "quality": { "target_defect_rate": 0.02, "actions": { "high_defects": "slow_line_and_inspect", "acceptable": "continue_normal" } }, "energy": { "max_consumption_kw": 150, "actions": { "over_limit": "load_balance" } } } # שמירת חוקים בDynamoDB dynamodb = boto3.resource('dynamodb') rules_table = dynamodb.Table('agent-decision-rules') rules_table.put_item(Item={ 'agent_id': 'temp-monitor-1', 'rules': decision_rules, 'updated_at': int(time.time()) })

חיבור למקורות נתונים בייצור

סוכן צריך קישוריות לחיישנים ומכשירים בקו הייצור. זה נעשה דרך AWS IoT Core, שיכולה להתחבר ל-PLC, מצלמות, חיישני טמפרטורה וכל מכשיר IoT אחר הנשלח נתונים דרך MQTT או HTTP.

# התחברות לIoT Core וקבלת נתונים בזמן אמת from awsiot import mqtt_connection_builder # הגדרת חיבור MQTT mqtt_connection = mqtt_connection_builder.websockets_with_default_creds( region='eu-central-1', client_id='agent-temp-monitor-1' ) # התחברות mqtt_connection.connect() # מנויות לטופיק קלט mqtt_connection.subscribe( topic='manufacturing/line1/temperature', qos=1, callback=process_temperature_reading ) def process_temperature_reading(topic, payload): data = json.loads(payload) print(f"Temperature: {data['celsius']}°C") # קבלת החלטה if data['celsius'] > 85: # בצע פעולה mqtt_connection.publish( topic='manufacturing/line1/actions', payload=json.dumps({"action": "reduce_power"}) ) # שמור חיבור פתוח mqtt_connection.disconnect()

בדיקה והדגמה

לפני הטמעה בייצור חי, חוקי להריץ את הסוכן בסביבת בדיקה עם נתונים דומים אך מבודדים. AWS מציעה את "AgentCore Simulator" שיכול לדמות קלט מחיישנים ולהראות איך הסוכן יגיב.

בדיקה מעמיקה כוללת: 1) בדיקת יחידה (Unit Test) על כל חוק החלטה בנפרד, 2) בדיקת שילוב (Integration Test) כדי להבטיח שחוקים שונים לא מתנגשים, 3) בדיקת עומס (Stress Test) להבטיח שהסוכן מטפל בקצב גבוה של נתונים.

בדיקות חוקיות

רשום תיעוד של כל בדיקה שעשית והתוצאה שלה. זה חיוני להסביר בהמשך למנהלים וודים איפה בדקת את הסוכן וכמה בטוח הוא.

4

סוכנים מתקדמים לתהליכים תעשייתיים

5 שעות

סוכנים לאופטימיזציה של קווי ייצור

סוכן אופטימיזציה הוא מערכת מתקדמת שמטרתה למצוא את הדרך הטובה ביותר לניהול קו ייצור. היא מעבדת מאות משתנים — מהירות קו, טמפרטורה, לחות, סדר המשימות — וממצאה את התצורה האופטימלית שמקסימה ייצור תוך שמיעה בהגבלות.

בעת אימון סוכן לאופטימיזציה, משתמשים בTechnique הנקראת "Reinforcement Learning" — הסוכן ניסיון דברים שונים, לומד מהתוצאות, וbit by bit מוצא דרכים טובות יותר.

# דוגמה: סוכן אופטימיזציה של קו ייצור class LineOptimizer: def __init__(self): self.max_speed = 100 # units/minute self.optimal_temp = 75 # celsius self.states = [] def decide_next_action(self, current_state): """ יקבע מה העדכון הטוב ביותר current_state: {'speed': 80, 'temp': 72, 'output': 1200} """ speed = current_state['speed'] temp = current_state['temp'] output = current_state['output'] # חישוב score (ציון) לפי נוכחי current_score = output * (self.optimal_temp / (temp ** 0.5)) actions = [ {'speed_delta': 1, 'temp_delta': 0}, {'speed_delta': -1, 'temp_delta': 0}, {'speed_delta': 0, 'temp_delta': 1}, {'speed_delta': 0, 'temp_delta': -1}, ] best_action = None best_score = current_score for action in actions: new_speed = speed + action['speed_delta'] new_temp = temp + action['temp_delta'] if 0 < new_speed <= self.max_speed and 60 < new_temp < 90: simulated_output = new_speed * (self.optimal_temp / (new_temp ** 0.5)) sim_score = simulated_output * (self.optimal_temp / (new_temp ** 0.5)) if sim_score > best_score: best_score = sim_score best_action = action return best_action or {'speed_delta': 0, 'temp_delta': 0} optimizer = LineOptimizer() best_adjustment = optimizer.decide_next_action({'speed': 75, 'temp': 74, 'output': 1150}) print(f"Best adjustment: {best_adjustment}")

סוכנים לאיתור תקלות ותחזוקה נבואית

סוכנים אלו לומדים מנתוני היסטוריים של המכשיר איך הוא "בדרך כלל פועל", ואז משווים את הנוכחי להנורמל. כשנראה חריגות, הסוכן משכיל שתקלה עומדת להיות — וזה הזמן לתיקון מונעה.

הטכניקה היא "Anomaly Detection" (זיהוי חריגות). אל תחכה שהמכונה תישבור; תחזו את זה קודם ותוקן מראש. זה יכול לחסוך מיליוני דולרים בזמן הפסק בלתי מתוכנן.

# סוכן תחזוקה נבואית עם Isolation Forest from sklearn.ensemble import IsolationForest import numpy as np class PredictiveMaintenanceAgent: def __init__(self): self.model = IsolationForest(contamination=0.05) self.trained = False def train_on_historical_data(self, historical_readings): """ historical_readings: array של [vibration, temp, power, sound] """ self.model.fit(historical_readings) self.trained = True def detect_anomaly(self, current_reading): """ current_reading: [vibration, temp, power, sound] returns: -1 (anomaly) or 1 (normal) """ if not self.trained: return 1 prediction = self.model.predict([current_reading]) if prediction[0] == -1: # חריגה זוהתה anomaly_score = self.model.score_samples([current_reading]) return { 'anomaly': True, 'severity': abs(anomaly_score[0]), 'action': 'schedule_maintenance' } return {'anomaly': False} # שימוש agent = PredictiveMaintenanceAgent() normal_data = np.random.randn(1000, 4) agent.train_on_historical_data(normal_data) result = agent.detect_anomaly([3.5, 85, 180, 95]) # חריג print(f"Detection: {result}")

סוכנים לניהול איכות ובקרה

סוכנים אלו עובדים בשיתוף עם מצלמות ו-Vision AI כדי לבדוק מוצרים בזמן סגור. הם יכולים לזהות פגמים זעירים שעין אנושית עלולה להחמיץ, ולמחול בעצמם להפסיק קו או להחזיר מוצרים בעיתיים.

משימות מולטי-סוכן וסינכרוניזציה

ניתן להריץ סוכנים רבים בו-זמנית בקו ייצור — אחד למהירות, אחד לטמפרטורה, אחד לאיכות. סוכנים אלו צריכים להיות מובנים ולא ליצור קונפליקטים. סינכרוניזציה מתבצעת דרך shared state ב-DynamoDB או דרך message queue כמו AWS SQS.

# דוגמה לשני סוכנים שעובדים ביחד class Agent: def __init__(self, name, dynamodb_table): self.name = name self.table = dynamodb_table def read_shared_state(self): response = self.table.get_item(Key={'line_id': 'line-1'}) return response.get('Item', {}) def update_shared_state(self, updates): self.table.update_item( Key={'line_id': 'line-1'}, AttributeUpdates={ 'last_update_by': {'Value': self.name}, **{k: {'Value': v} for k, v in updates.items()} } ) # Agent A אחראי על מהירות agent_speed = Agent('SpeedOptimizer', table) state = agent_speed.read_shared_state() current_speed = state.get('current_speed', 50) new_speed = current_speed + 5 agent_speed.update_shared_state({'current_speed': new_speed}) # Agent B אחראי על טמפרטורה agent_temp = Agent('TemperatureController', table) state = agent_temp.read_shared_state() current_temp = state.get('current_temp', 75) if current_temp > 80: agent_speed.update_shared_state({'current_speed': current_speed - 2}) # הוריד מהירות אם חם

תיאום סוכנים

כאשר סוכנים מרובים פועלים, חשוב להגדיר "פקודת הירארכיה" — מי בעדיפות גבוהה בתיקומים? בדרך כלל, בטיחות היא הגבוהה ביותר, אחריה איכות, ואז יעילות.

5

ניטור, שלוט וביטחון

4 שעות

בנייה של לוח בקרה וניטור בזמן אמת

לוח בקרה (Dashboard) הוא הממשק הראשי של המפעיל לראות מה הסוכנים עושים. זה צריך להיות פשוט וברור — תצוגה של מצב כל סוכן, גרפים של ביצועים, וכפתורים לבקרה ידנית אם צריך.

AWS CloudWatch מאפשרת ליצור לוח בקרה מותאם אישית, עם מטריקות בזמן אמת, אזעקות, וקישוריות לכל AWS services אחרות. ניתן לבנות לוח בקרה קטן (Dashboard) או פנל גדול במעבדה/משרד.

# יצירת לוח בקרה בCloudWatch import boto3 import json cloudwatch = boto3.client('cloudwatch') dashboard_body = { "widgets": [ { "type": "metric", "properties": { "metrics": [ ["AgentCore", "AgentActiveCount", {"stat": "Average"}], ["AgentCore", "DecisionsPerMinute"], ["AgentCore", "AnomaliesDetected"], ["AgentCore", "AvgDecisionLatency", {"stat": "Average"}] ], "period": 60, "stat": "Average", "region": "eu-central-1", "title": "סוכנים — מטריקות כלליות" } }, { "type": "metric", "properties": { "metrics": [ ["AgentCore", "LineSpeed", {"dimensions": {"AgentId": "speed-opt-1"}}], ["AgentCore", "LineTemperature", {"dimensions": {"AgentId": "temp-ctrl-1"}}] ], "title": "קו 1 — פרמטרים" } }, { "type": "log", "properties": { "query": "fields @timestamp, @message, agentId | filter @message like /ERROR/ | stats count() by agentId", "region": "eu-central-1", "title": "שגיאות סוכן" } } ] } cloudwatch.put_dashboard( DashboardName='ManufacturingAgents', DashboardBody=json.dumps(dashboard_body) ) print("Dashboard created successfully!")

כלים של CloudWatch ו-AgentCore Dashboard

CloudWatch Logs שומר את כל היומנים של סוכנים — כל החלטה, כל שגיאה, כל פעולה. ניתן לחפש ולנתח יומנים אלו כדי להבין מה התרחש בעבר ולאבחן בעיות.

AgentCore Dashboard הוא ממשק מבונה מראש שמראה את כל הסוכנים, מצבם, ביצועיהם וקצב השגיאות. הוא מעדכן עצמו כל 5 שניות.

ניהול הרשאות IAM לסוכנים

כל סוכן צריך הרשאות ספציפיות ב-IAM (Identity and Access Management) כדי לגשת לשירותים בהם הוא צריך. למשל, סוכן שמנהל מלאי צריך הרשאה לקרוא מ-DynamoDB אבל לא צריך הרשאה לעדכן חשבות חיוב.

# יצירת IAM role לסוכן import json iam = boto3.client('iam') trust_policy = { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "agentcore.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } # יצירת role response = iam.create_role( RoleName='ManufacturingAgentRole', AssumeRolePolicyDocument=json.dumps(trust_policy) ) # הוספת policy להרשאות agent_policy = { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem" ], "Resource": "arn:aws:dynamodb:eu-central-1:123456789:table/AgentState" }, { "Effect": "Allow", "Action": [ "iot:Publish", "iot:Subscribe" ], "Resource": "arn:aws:iot:eu-central-1:123456789:topic/manufacturing/*" } ] } iam.put_role_policy( RoleName='ManufacturingAgentRole', PolicyName='AgentExecutionPolicy', PolicyDocument=json.dumps(agent_policy) ) print("IAM role created with limited permissions")

הצפנה ואבטחת תקשורת

כל נתון שמעביר סוכן צריך להיות מוצפן בדרכו — בין סוכן לחיישן, בין סוכן לענן, בכל מקום. AWS משתמשת בTLS 1.2 וגבוה יותר בברירת מחדל, אבל צריך לוודא שה-configuration נכון.

# וודוא הצפנה בקישור MQTT mqtt_connection = mqtt_connection_builder.websockets_with_default_creds( region='eu-central-1', client_id='secure-agent-1', ca_filepath='/path/to/Amazon-root-CA-1.pem', cert_filepath='/path/to/certificate.pem.crt', prikey_filepath='/path/to/private.pem.key' ) # וודא TLS version import ssl mqtt_connection.websockets_connection.ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2 mqtt_connection.connect() # בדיקה: כל הודעה יוצפנת mqtt_connection.publish( topic='manufacturing/sensitive/data', payload=json.dumps({ "status": "encrypted", "timestamp": time.time() }), qos=1 )

ביטחון זהו תהליך

אל תחשוב על ביטחון כדבר שעושים פעם אחת. בדוק באופן קבוע את הרשאות, עדכן certificates, שנה סיסמאות. כל חודש, כל שלוש חודשים — זה תלוי בסיכון שלך.

6

הטמעה בסביבה תעשייתית

4.3 שעות

תכנון דרגים בהטמעה

הטמעה בקו ייצור חי היא מעשה כבד. לא עושים זאת בהנתקה אחת — עושים זאת בשלבים, כשכל שלב בדוק ומתוכנן. דרגה ראשונה יכולה להיות בסוכן אחד בקו אחד. אם מצליח, דרגה שנייה — כמה סוכנים. אם עדיין טוב, דרגה שלישית — כל קו הייצור.

כל דרגה צריכה להיות עם rollback plan — אם משהו לא עובד, איך חוזרים למצב הקודם? בדרך כלל זה אומר שמור backup של configurationים ישנים וציוד מחוזיר למצב ידנוי אם סוכנים מפרים תהליכים.

התחברות לציוד קיים (IIoT, Sensors, PLC)

קו ייצור קיים כבר יש חיישנים, PLCs (Programmable Logic Controllers), ועוד ציוד. סוכנים צריכים להשתלב איתם. זה נעשה דרך AWS IoT Core ודרך Connectors שמבינים פרוטוקולים שונים — Modbus, OPC-UA, PROFIBUS וכל מה שקיים בעולם התעשייה.

# דוגמה: התחברות לPLC דרך Modbus עברور Raspberry Pi from pymodbus.client import ModbusTcpClient as ModbusClient import json import time from awsiot import mqtt_connection_builder # התחברות לPLC plc = ModbusClient(host='192.168.1.100', port=502) # התחברות לAWS IoT mqtt = mqtt_connection_builder.websockets_with_default_creds( region='eu-central-1', client_id='plc-bridge-1' ) mqtt.connect() # קריאה מPLC ושליחה לAWS while True: regs = plc.read_holding_registers(0, 10) if regs: data = { 'timestamp': int(time.time() * 1000), 'registers': regs.registers, 'source': 'PLC_Line1' } mqtt.publish( topic='manufacturing/plc/readings', payload=json.dumps(data), qos=1 ) time.sleep(0.5)

אופטימיזציית ביצועים וקנה מידה

כל סוכן עוצמה משאבים — CPU, זיכרון, חיבור רשת. כאשר מטמיעים עשרות או מאות סוכנים, צריך להבטיח שהמערכת לא מתורסקת. זה עושים דרך Auto Scaling — AWS עוזר להוסיף משאבים באופן אוטומטי כשהם צריכים, ולהסיר כשלא צריכים.

ניהול עדכונים והיסטוריה

סוכנים צריכים עדכונים מעת לעת — תיקונים, שיפורים, חוקים חדשים. כל עדכון חייב להיבדק קודם בבדיקה. כאשר מעדכנים סוכן בייצור, צריך לשמור גרסה ישנה כדי שאם משהו פתאום קלקול, ניתן לחזור אחורה תוך דקות, לא שעות.

# ניהול גרסאות של סוכנים import boto3 import time s3 = boto3.client('s3') def deploy_agent_version(agent_id, new_config, bucket='agent-versions'): timestamp = int(time.time()) version_key = f"agents/{agent_id}/v{timestamp}.json" # שמירה בS3 s3.put_object( Bucket=bucket, Key=version_key, Body=json.dumps(new_config), Metadata={ 'agent-id': agent_id, 'timestamp': str(timestamp), 'deployed-by': 'automation-system' } ) # עדכון סוכן בפועל agentcore = boto3.client('agentcore') agentcore.update_agent( agent_id=agent_id, config=json.dumps(new_config), version=timestamp ) return version_key def rollback_agent(agent_id, previous_timestamp): # קבלת קונפיג ישנה מS3 response = s3.get_object( Bucket='agent-versions', Key=f"agents/{agent_id}/v{previous_timestamp}.json" ) old_config = json.loads(response['Body'].read()) # חזרה לקונפיג ישנה agentcore = boto3.client('agentcore') agentcore.update_agent( agent_id=agent_id, config=json.dumps(old_config), version=previous_timestamp ) print("Version management ready")

תכנון הטמעה

השתמש בשיטת "Canary Deployment" — הפעל סוכן חדש על 1% מהטרפיק קודם, עקוב אחרי התוצאות, ואז הגדל. אם כל משהו בסדר, 100%; אם יש בעיה, סוכן ישן מיד חוזר.

7

אחסון נתונים וניתוח

4.7 שעות

שמירת נתוני סוכן ב-S3 ו-DynamoDB

סוכנים מייצרים כמויות ענקיות של נתונים — כל החלטה, כל קריאת חיישן, כל פעולה. צריך למקום נתונים אלו כדי שלא יהיו בזכרון הנדיף של הסוכן (שדורס כשהוא מכבים).

DynamoDB משמשת למצב סוכן בזמן אמת — מה הוא עושה עכשיו. S3 משמשת לאחסון נתונים היסטוריים — ניתוח חודשי, בדיקות ארכיוני.

# שמירת נתונים בDynamoDB (real-time) dynamodb = boto3.resource('dynamodb') agent_state_table = dynamodb.Table('AgentState') def update_agent_state(agent_id, state_data): agent_state_table.put_item(Item={ 'agent_id': agent_id, 'timestamp': int(time.time() * 1000), 'current_state': state_data['state'], 'last_decision': state_data['decision'], 'metrics': { 'decision_latency_ms': state_data['latency'], 'confidence': state_data['confidence'] }, 'ttl': int(time.time()) + (24 * 3600) # שמור 24 שעות בלבד }) # שמירת היסטוריה בS3 s3 = boto3.client('s3') def archive_agent_history(agent_id, history_data): date_str = time.strftime('%Y/%m/%d') s3_key = f"agent-history/{agent_id}/{date_str}/{agent_id}-{int(time.time())}.json" s3.put_object( Bucket='agent-historical-data', Key=s3_key, Body=json.dumps(history_data, default=str), ServerSideEncryption='AES256' )

שימוש ב-AWS Glue לעיבוד נתונים

Glue היא שירות ETL (Extract-Transform-Load) — היא קוראה נתונים מS3, מעבדת אותם (מנקה, משלבת, משנה), ושומרת לפורמט שימושי לניתוח. למשל, Glue יכול להתחבר לנתונים בחו של חיישנים שונים ליצור טבלה אחת גדולה.

# יצירת Glue ETL job import boto3 glue = boto3.client('glue') job_definition = { "Name": "AgentDataProcessing", "Description": "Process agent sensor data and aggregate", "Role": "arn:aws:iam::123456789:role/GlueExecutionRole", "Command": { "Name": "glueetl", "ScriptLocation": "s3://my-scripts/glue/agent_processing.py" }, "DefaultArguments": { "--job-bookmark-option": "job-bookmark-enabled", "--TempDir": "s3://my-temp/glue/", "--output-bucket": "agent-processed-data" }, "MaxRetries": 1, "Timeout": 2880, "MaxCapacity": 10 } glue.create_job(**job_definition)

ניתוח עם Amazon QuickSight

QuickSight הוא כלי BI (Business Intelligence) שיוצר דוחות וגרפים יפים מנתונים. דירקטור או מנהל יכול לראות בלוח בקרה אחד את כל המטריקות החשובות של הייצור בגרפים וטבלאות.

Machine Learning ופיתוח דגמים עם SageMaker

SageMaker היא פלטפורמת ML מלאה. ניתן להשתמש בה לאימון מודלים שסוכנים ישתמשו בהם בהחלטות. למשל, מודל שנאמן על יסטוריה יכול להעריך את ההסתברות שמכונה תישבור בשבוע הקרוב.

# יצירת מודל SageMaker ל-predictive maintenance import sagemaker from sagemaker.xgboost import XGBoost role = sagemaker.get_execution_role() session = sagemaker.Session() xgb = XGBoost( entry_point='training.py', role=role, instance_type='ml.m5.xlarge', instance_count=1, framework_version='latest', hyperparameters={ 'max_depth': 7, 'eta': 0.2, 'objective': 'binary:logistic', 'num_round': 100 } ) # אימון המודל xgb.fit( {'training': 's3://my-training-data/maintenance/'}, wait=True ) # פריסה xgb.deploy(initial_instance_count=1, instance_type='ml.m5.xlarge')

נתונים היא זהב

ככל שיותר נתונים אתה אוסף (בצורה חכמה), כך טוב יותר סוכנים שלך יהיו בעתיד. אל תשלח נתונים לא רלוונטיים — זה רק מגביל מקום וקונים משאבים.

8

פרויקט מסכם והטמעה בפועל

5 שעות

סקירת פרויקטים בעולם האמת

בעולם האמת, חברות ייצור גדולות (כמו טזיוטה, סיימנס, יוגר) כבר משתמשות בסוכני AI לייצור חכם. הם עברו כל הדרך — מחשיבה ראשונית, דרך ניסוי, ברקע הטמעה בקנה מידה. פרויקטים אלו לקחו חודשים ותקציב של מיליוני דולרים, אבל התוצאות הן משמעותיות — חיסכון ב-20-40% בעלויות, הפחתת פגמים ב-50%+.

כדי להיות מוכן לעולם האמת, עליך להבין לא רק את הטכנולוגיה אלא גם את הקשיים האנושיים והארגוניים — איך משכנעים מנהלים? איך מאמנים אופרטורים? איך מתמודדים עם התנגדות לשינוי?

בנייה של מערכת סוכנים מורכבת

הפרויקט המסכם שלך היא בנייה של מערכת סוכנים שלמה — לא סוכן אחד, אלא מערכת שלמה של 5-10 סוכנים העובדים יחד בהרמוניה. זה כולל סוכנים לאופטימיזציה, לבקרת איכות, לתחזוקה נבואית, ולניהול משימות.

# ארכיטקטורה של מערכת סוכנים מורכבת MANUFACTURING_SYSTEM_ARCHITECTURE = { "system_id": "smart-line-1", "agents": [ { "id": "speed-optimizer", "type": "optimizer", "target": "line_speed", "priority": 2 }, { "id": "temp-controller", "type": "controller", "target": "temperature", "priority": 1 }, { "id": "quality-inspector", "type": "inspector", "target": "defect_detection", "priority": 1 }, { "id": "maintenance-predictor", "type": "predictor", "target": "equipment_health", "priority": 2 }, { "id": "energy-manager", "type": "optimizer", "target": "power_consumption", "priority": 3 }, { "id": "logistics-coordinator", "type": "coordinator", "target": "material_flow", "priority": 2 } ], "communication": { "type": "message_bus", "backend": "aws_sqs", "update_frequency_ms": 500 }, "state_backend": "dynamodb", "monitoring": "cloudwatch" } # יצירת המערכת def initialize_manufacturing_system(config): """ יצירה ודרגה של כל סוכנים במערכת """ agentcore = boto3.client('agentcore') for agent_config in config["agents"]: response = agentcore.create_agent( name=agent_config["id"], config=json.dumps(agent_config) ) print(f"Agent {agent_config['id']} created: {response['agent_id']}") return True

טסטינג מקיף וביצוע

לפני הפעלה בחי, יש לבדוק:

  • Unit Tests: כל סוכן בנפרד — האם הוא עושה מה שהוא אמור?
  • Integration Tests: סוכנים ביחד — האם הם מסכימים ולא מתנגשים?
  • Load Tests: בעומס גבוה — האם המערכת חזקה?
  • Chaos Tests: מחיקת חלקים באופן אקראי — האם המערכת עמידה?
  • Compliance Tests: האם המערכת עומדת בתקנות תעשייה וביטחון?
# דוגמה: בדיקת עומס עם Locust from locust import HttpUser, task, between import random class AgentLoadTest(HttpUser): wait_time = between(0.5, 2) @task def create_agent_decision(self): """ סימול החלטות רבות מסוכנים """ decision = { "agent_id": f"agent-{random.randint(1, 10)}", "decision": random.choice(["speed_up", "slow_down", "alert"]), "confidence": random.uniform(0.7, 0.99), "timestamp": int(time.time() * 1000) } self.client.post( "/api/agents/decision", json=decision ) @task def read_agent_state(self): agent_id = f"agent-{random.randint(1, 10)}" self.client.get(f"/api/agents/{agent_id}/state") # הפעלת בדיקה: locust -f locust_tests.py --host=http://localhost:8000

הצגת תוצאות וטיפים לעתיד

בסיום הפרויקט, עליך להצגת תוצאות לחברה:

  • כמה השתפר הייצור? (גדל בכמה %)
  • כמה פחתו פגמים? (ירידה בכמה %)
  • כמה חסכנו בעלויות? (בדולרים או יורו)
  • כמה זה עלה להטמיע? (בעלויות פיתוח וציוד)
  • מה ה-ROI (Return on Investment)? (לעשות את הרווח חלקי ההשקעה)

טיפים לעתיד: 1) אל תבנה מערכת מושלמת בפעם הראשונה — התחל קטן וגדל. 2) שמע לאופרטורים — הם יודעים מה בעיות קיימות. 3) עקוב אחרי KPIs ברציפות — מה עובד וחה לא. 4) עדכן וחדש סוכנים כמו כל 3-6 חודשים — תיכנית ML משתנה כשהתהליך משתנה.

המעבר לייצור חכם

טכנולוגיה זו לא רק עוזרת לייצור — היא משנה את התרבות של החברה. עובדים מופכים למחנכי מערכות ולא לעובדי קו. זה סוג של עתיד שמענה עדיפות גבוהה לאנשים ולמיומנויות שלהם.

שאלות נפוצות

מה צריך להכין לפני תחילת הקורס?

נדרשת ידע בסיסי בפייתון, הבנה של מושגי ענן (AWS), וכלים כמו terminal ו-Git. מומלץ להכיר מושגים בסיסיים של machine learning.

האם צריך חשבון AWS משלי?

כן. נדרש חשבון AWS פעיל. ניתן להשתמש ב-AWS Free Tier עבור חלק גדול של הקורס, אך יתכן יהיה צורך בתקציב קטן לבדיקה של פיתורים מתקדמים.

כמה זמן ייקח להשלים את הקורס?

32 שעות של תוכן מובנה. בהתחשב בתרגולים ופרויקטים מעשיים, מומלץ להקציב 8-12 שבועות ללמידה בקצב ממוצע.

האם אקבל תעודה בסיום?

כן! בהשלמת כל המודולים ועבודת הפרויקט המסכם, תקבל תעודה מוכרת שמוכיחה שליטה בהטמעת סוכני AI לתעשייה.

מה אוכל לעשות עם הידע הזה?

תוכל לעבוד כ-AI Systems Engineer, Manufacturing AI Specialist, או AWS Solutions Architect בתחום התעשייה, להטמיע סוכנים בחברות ייצור, או לפתח פתרונות מותאמים.

האם יש תמיכה בעברית?

כל התוכן הוא בעברית - שיעורים, תרגילים, ודוקומנטציה. יש גם קהילה מומחים בעברית לשאלות.

האם צריך ידע בייצור או IoT?

לא הכרחי. הקורס מחקה מושגים בייצור ו-IoT מהיסוד. אך אם יש לך רקע בתעשייה, זה יעזור בהבנת מקרי השימוש.

האם יש תוכן עדכני ל-2024?

כן! התוכן מעודכן עם הגרסאות האחרונות של AWS AgentCore ובעדכונים אחרונים בתחום AI לתעשייה.

מוכן להתחיל?

קורס זה יקנה לך את כל הכישורים הדרושים להיות מומחה בהטמעת סוכני AI בתעשייה. התחל עכשיו, בקצב שלך.