AI Development Trends 2025: What Every Developer Needs to Know

import openai
from PIL import Image
import base64
import io

class MultimodalAIProcessor:
    def __init__(self, api_key):
        self.client = openai.OpenAI(api_key=api_key)
    
    def analyze_image_with_text(self, image_path, text_prompt):
        """
        Analyze an image with accompanying text using GPT-4V
        """
        # Encode image to base64
        with open(image_path, "rb") as image_file:
            base64_image = base64.b64encode(image_file.read()).decode('utf-8')
        
        response = self.client.chat.completions.create(
            model="gpt-4-vision-preview",
            messages=[
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": text_prompt
                        },
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": f"data:image/jpeg;base64,{base64_image}"
                            }
                        }
                    ]
                }
            ],
            max_tokens=500
        )
        
        return response.choices[0].message.content
    
    def generate_image_from_description(self, description, style="realistic"):
        """
        Generate an image from text description using DALL-E 3
        """
        response = self.client.images.generate(
            model="dall-e-3",
            prompt=f"{description}, {style} style",
            size="1024x1024",
            quality="standard",
            n=1
        )
        
        return response.data[0].url
    
    def transcribe_and_analyze_audio(self, audio_file_path):
        """
        Transcribe audio and analyze the content
        """
        # Transcribe audio
        with open(audio_file_path, "rb") as audio_file:
            transcript = self.client.audio.transcriptions.create(
                model="whisper-1",
                file=audio_file
            )
        
        # Analyze the transcribed text
        analysis = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {
                    "role": "system",
                    "content": "Analyze the following transcribed audio for sentiment, key topics, and actionable insights."
                },
                {
                    "role": "user",
                    "content": transcript.text
                }
            ]
        )
        
        return {
            "transcript": transcript.text,
            "analysis": analysis.choices[0].message.content
        }
    
    def create_multimodal_summary(self, text, image_path, audio_path):
        """
        Create a comprehensive summary using multiple modalities
        """
        # Process each modality
        image_analysis = self.analyze_image_with_text(
            image_path, 
            "Describe what you see in this image in detail."
        )
        
        audio_analysis = self.transcribe_and_analyze_audio(audio_path)
        
        # Combine all information
        combined_prompt = f"""
        Create a comprehensive summary based on the following multimodal information:
        
        Text Content: {text}
        
        Image Analysis: {image_analysis}
        
        Audio Transcript: {audio_analysis['transcript']}
        Audio Analysis: {audio_analysis['analysis']}
        
        Provide a unified summary that incorporates insights from all modalities.
        """
        
        summary = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {
                    "role": "user",
                    "content": combined_prompt
                }
            ]
        )
        
        return summary.choices[0].message.content

# Usage example
processor = MultimodalAIProcessor("your-api-key")

# Analyze image with text
result = processor.analyze_image_with_text(
    "product_image.jpg",
    "What are the key features of this product? How would you market it?"
)

print("Image Analysis:", result)

import openai
import json
import requests
from typing import List, Dict, Any

class AIAgent:
    def __init__(self, api_key: str, name: str, role: str):
        self.client = openai.OpenAI(api_key=api_key)
        self.name = name
        self.role = role
        self.memory = []
        self.tools = {}
        self.conversation_history = []
    
    def add_tool(self, name: str, function: callable, description: str):
        """Add a tool that the agent can use"""
        self.tools[name] = {
            'function': function,
            'description': description
        }
    
    def remember(self, information: str):
        """Add information to agent's memory"""
        self.memory.append({
            'timestamp': datetime.now().isoformat(),
            'information': information
        })
    
    def plan_task(self, goal: str) -> List[Dict[str, Any]]:
        """Create a plan to achieve the given goal"""
        available_tools = "\n".join([
            f"- {name}: {info['description']}" 
            for name, info in self.tools.items()
        ])
        
        planning_prompt = f"""
        You are {self.name}, a {self.role}. 
        
        Goal: {goal}
        
        Available tools:
        {available_tools}
        
        Memory context:
        {self.get_memory_context()}
        
        Create a step-by-step plan to achieve this goal. For each step, specify:
        1. Action description
        2. Tool to use (if any)
        3. Expected outcome
        
        Return the plan as a JSON array of steps.
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are an AI agent that creates detailed execution plans."},
                {"role": "user", "content": planning_prompt}
            ],
            temperature=0.1
        )
        
        try:
            plan = json.loads(response.choices[0].message.content)
            return plan
        except json.JSONDecodeError:
            # Fallback to simple plan
            return [{"action": "Execute goal directly", "tool": None, "outcome": goal}]
    
    def execute_plan(self, plan: List[Dict[str, Any]]) -> Dict[str, Any]:
        """Execute the planned steps"""
        results = []
        
        for step in plan:
            print(f"Executing: {step['action']}")
            
            if step.get('tool') and step['tool'] in self.tools:
                # Use the specified tool
                tool_result = self.use_tool(step['tool'], step)
                results.append({
                    'step': step,
                    'result': tool_result,
                    'status': 'completed'
                })
            else:
                # Execute using general reasoning
                result = self.reason_and_act(step['action'])
                results.append({
                    'step': step,
                    'result': result,
                    'status': 'completed'
                })
            
            # Remember the result
            self.remember(f"Completed: {step['action']} - Result: {results[-1]['result']}")
        
        return {
            'plan': plan,
            'results': results,
            'status': 'completed'
        }
    
    def use_tool(self, tool_name: str, context: Dict[str, Any]) -> Any:
        """Use a specific tool"""
        if tool_name not in self.tools:
            return f"Tool {tool_name} not available"
        
        try:
            return self.tools[tool_name]['function'](context)
        except Exception as e:
            return f"Error using tool {tool_name}: {str(e)}"
    
    def reason_and_act(self, action: str) -> str:
        """Use reasoning to perform an action"""
        reasoning_prompt = f"""
        As {self.name}, a {self.role}, perform this action: {action}
        
        Context from memory:
        {self.get_memory_context()}
        
        Provide a detailed response about how you would perform this action and what the result would be.
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "user", "content": reasoning_prompt}
            ],
            temperature=0.3
        )
        
        return response.choices[0].message.content
    
    def get_memory_context(self) -> str:
        """Get relevant context from memory"""
        if not self.memory:
            return "No previous context"
        
        # Return last 5 memory items
        recent_memory = self.memory[-5:]
        return "\n".join([item['information'] for item in recent_memory])
    
    def chat(self, message: str) -> str:
        """Have a conversation with the agent"""
        self.conversation_history.append({"role": "user", "content": message})
        
        system_prompt = f"""
        You are {self.name}, a {self.role}. 
        You have access to tools and can remember information.
        
        Available tools: {list(self.tools.keys())}
        Recent memory: {self.get_memory_context()}
        """
        
        messages = [{"role": "system", "content": system_prompt}] + self.conversation_history
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=messages,
            temperature=0.7
        )
        
        agent_response = response.choices[0].message.content
        self.conversation_history.append({"role": "assistant", "content": agent_response})
        
        return agent_response

# Example tools
def web_search(context):
    """Simulate web search"""
    query = context.get('query', context.get('action', ''))
    return f"Search results for: {query}"

def send_email(context):
    """Simulate sending email"""
    return f"Email sent: {context.get('message', 'Default message')}"

def analyze_data(context):
    """Simulate data analysis"""
    return f"Data analysis completed for: {context.get('data', 'provided data')}"

# Usage example
agent = AIAgent("your-api-key", "DataAnalyst", "Senior Data Analyst")

# Add tools
agent.add_tool("web_search", web_search, "Search the web for information")
agent.add_tool("send_email", send_email, "Send email notifications")
agent.add_tool("analyze_data", analyze_data, "Perform data analysis")

# Execute a complex task
goal = "Research market trends for AI development tools and create a summary report"
plan = agent.plan_task(goal)
results = agent.execute_plan(plan)

print("Task completed:", results)

# Example using Qiskit for quantum machine learning
from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit.library import ZZFeatureMap, TwoLocal
from qiskit_machine_learning.algorithms import VQC
from qiskit_machine_learning.neural_networks import CircuitQNN
import numpy as np

class QuantumMLClassifier:
    def __init__(self, num_features=2, num_qubits=4):
        self.num_features = num_features
        self.num_qubits = num_qubits
        self.feature_map = None
        self.ansatz = None
        self.vqc = None
        
    def create_feature_map(self):
        """Create quantum feature map for encoding classical data"""
        self.feature_map = ZZFeatureMap(
            feature_dimension=self.num_features,
            reps=2,
            entanglement='linear'
        )
        return self.feature_map
    
    def create_ansatz(self):
        """Create variational ansatz for the quantum circuit"""
        self.ansatz = TwoLocal(
            num_qubits=self.num_qubits,
            rotation_blocks='ry',
            entanglement_blocks='cz',
            entanglement='linear',
            reps=3
        )
        return self.ansatz
    
    def build_classifier(self):
        """Build the variational quantum classifier"""
        if self.feature_map is None:
            self.create_feature_map()
        if self.ansatz is None:
            self.create_ansatz()
            
        # Create quantum neural network
        qnn = CircuitQNN(
            circuit=self.feature_map.compose(self.ansatz),
            input_params=self.feature_map.parameters,
            weight_params=self.ansatz.parameters,
            interpret=self.parity,
            output_shape=2
        )
        
        # Create variational quantum classifier
        self.vqc = VQC(
            quantum_instance=Aer.get_backend('qasm_simulator'),
            feature_map=self.feature_map,
            ansatz=self.ansatz,
            optimizer='COBYLA',
            quantum_kernel=None
        )
        
        return self.vqc
    
    def parity(self, x):
        """Parity function for interpreting quantum measurements"""
        return '{:b}'.format(x).count('1') % 2
    
    def train(self, X_train, y_train):
        """Train the quantum classifier"""
        if self.vqc is None:
            self.build_classifier()
            
        self.vqc.fit(X_train, y_train)
        return self
    
    def predict(self, X_test):
        """Make predictions using the trained quantum classifier"""
        return self.vqc.predict(X_test)
    
    def score(self, X_test, y_test):
        """Calculate accuracy score"""
        predictions = self.predict(X_test)
        return np.mean(predictions == y_test)

# Quantum advantage demonstration
class QuantumAdvantageDemo:
    def __init__(self):
        self.classical_time = 0
        self.quantum_time = 0
    
    def classical_optimization(self, problem_size):
        """Simulate classical optimization"""
        import time
        start_time = time.time()
        
        # Simulate classical algorithm (exponential complexity)
        result = 0
        for i in range(2**min(problem_size, 20)):  # Cap to prevent infinite runtime
            result += i * 0.001
        
        self.classical_time = time.time() - start_time
        return result
    
    def quantum_optimization(self, problem_size):
        """Simulate quantum optimization"""
        import time
        start_time = time.time()
        
        # Create quantum circuit for optimization
        qc = QuantumCircuit(problem_size)
        
        # Apply Hadamard gates for superposition
        for i in range(problem_size):
            qc.h(i)
        
        # Apply problem-specific gates
        for i in range(problem_size - 1):
            qc.cz(i, i + 1)
        
        # Measure all qubits
        qc.measure_all()
        
        # Execute on simulator
        backend = Aer.get_backend('qasm_simulator')
        job = execute(qc, backend, shots=1024)
        result = job.result()
        
        self.quantum_time = time.time() - start_time
        return result.get_counts()
    
    def compare_performance(self, problem_sizes):
        """Compare classical vs quantum performance"""
        results = []
        
        for size in problem_sizes:
            print(f"Testing problem size: {size}")
            
            classical_result = self.classical_optimization(size)
            quantum_result = self.quantum_optimization(size)
            
            speedup = self.classical_time / self.quantum_time if self.quantum_time > 0 else float('inf')
            
            results.append({
                'problem_size': size,
                'classical_time': self.classical_time,
                'quantum_time': self.quantum_time,
                'speedup': speedup
            })
        
        return results

# Usage example
if __name__ == "__main__":
    # Quantum ML Classification
    qml_classifier = QuantumMLClassifier(num_features=2, num_qubits=4)
    
    # Generate sample data
    X_train = np.random.random((100, 2))
    y_train = np.random.randint(0, 2, 100)
    X_test = np.random.random((20, 2))
    y_test = np.random.randint(0, 2, 20)
    
    # Train and evaluate
    qml_classifier.train(X_train, y_train)
    accuracy = qml_classifier.score(X_test, y_test)
    print(f"Quantum ML Classifier Accuracy: {accuracy:.2f}")
    
    # Quantum advantage demonstration
    demo = QuantumAdvantageDemo()
    problem_sizes = [4, 6, 8, 10]
    performance_results = demo.compare_performance(problem_sizes)
    
    for result in performance_results:
        print(f"Problem size {result['problem_size']}: "
              f"Speedup = {result['speedup']:.2f}x")