artificial intelligence for everything import torch from transformers import BertTokenizer, BertForSequenceClassification
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2) # Change num_labels based on your task
def classify_request(request): # Tokeniser la demande inputs = tokenizer(request, return_tensors="pt", truncation=True, padding=True)
# Obtenir les prédictions du modèle
with torch.no_grad():
outputs = model(**inputs)
# Convertir les sorties en probabilités
probabilities = torch.softmax(outputs.logits, dim=-1)
# Prendre la classe prédite (0 ou 1)
predicted_class = torch.argmax(probabilities).item()
return predicted_class
request = "Quelle est la météo aujourd'hui ?" predicted_class = classify_request(request)
if predicted_class == 0: print("Demande classifiée comme 'demande d'information'.") else: print("Demande classifiée comme 'autre type de demande'.") import requests
def search_online(query, api_key): # URL de l'API de SerpAPI url = "https://serpapi.com/search.json"
# Paramètres de la requête
params = {
"q": query, # Le terme de recherche
"api_key": api_key, # Ta clé API
}
# Effectuer la requête
response = requests.get(url, params=params)
# Vérifier si la requête a réussi
if response.status_code == 200:
results = response.json()
return results['organic_results'] # Retourner les résultats organiques
else:
return f"Erreur lors de la recherche : {response.status_code}"
api_key = "TA_CLE_API_SERPAPI" query = "impact de l'intelligence artificielle sur l'emploi" results = search_online(query, api_key)
for result in results: print(result['title']) print(result['link']) print() import requests import openai
SERPAPI_KEY = "TA_CLE_API_SERPAPI" # Remplace avec ta clé SerpAPI OPENAI_API_KEY = "TA_CLE_API_OPENAI" # Remplace avec ta clé OpenAI
def search_online(query, api_key): url = "https://serpapi.com/search.json" params = {"q": query, "api_key": api_key} response = requests.get(url, params=params) if response.status_code == 200: results = response.json() return results['organic_results'][:3] # Limiter à 3 résultats pour la démonstration else: return []
def generate_content(topic, search_results): openai.api_key = OPENAI_API_KEY
# Construire un prompt basé sur les résultats de recherche
prompt = f"Crée un article de blog informatif sur le sujet suivant : {topic}. Voici quelques informations trouvées en ligne :\n\n"
for result in search_results:
prompt += f"- Titre : {result['title']}\nDescription : {result.get('snippet', 'Aucune description')}\nURL : {result['link']}\n\n"
prompt += "En utilisant ces informations, écris un article clair et bien structuré sur ce sujet."
# Générer du texte avec GPT
response = openai.Completion.create(
engine="gpt-4", # Utilisation du modèle GPT-4
prompt=prompt,
max_tokens=500 # Limite du nombre de mots générés
)
return response['choices'][0]['text']
topic = "impact de l'intelligence artificielle sur l'emploi" search_results = search_online(topic, SERPAPI_KEY)
if search_results: content = generate_content(topic, search_results) print(content) else: print("Aucun résultat trouvé pour la recherche.") from fpdf import FPDF
def text_to_pdf(text, output_pdf_file): # Créer un objet PDF pdf = FPDF() pdf.add_page()
# Définir la police et la taille du texte
pdf.set_font("Arial", size=12)
# Ajouter du texte au PDF
pdf.multi_cell(200, 10, txt=text, align="L")
# Sauvegarder le fichier PDF
pdf.output(output_pdf_file)
print(f"PDF généré : {output_pdf_file}")
text_content = "Ceci est un exemple de texte converti en PDF." output_pdf = "output_file.pdf" text_to_pdf(text_content, output_pdf) from moviepy.editor import TextClip, CompositeVideoClip from gtts import gTTS from moviepy.editor import AudioFileClip
def text_to_mp4(text, output_mp4_file): # Générer une voix à partir du texte (gTTS) tts = gTTS(text, lang='fr') tts.save("voice.mp3")
# Créer une vidéo avec le texte (fond noir, texte blanc)
text_clip = TextClip(text, fontsize=24, color='white', size=(1280, 720), bg_color='black', method='caption')
text_clip = text_clip.set_duration(10) # Durée de la vidéo
# Ajouter l'audio à la vidéo
audio_clip = AudioFileClip("voice.mp3")
video = text_clip.set_audio(audio_clip)
# Sauvegarder la vidéo en MP4
video.write_videofile(output_mp4_file, fps=24)
print(f"Vidéo MP4 générée : {output_mp4_file}")
text_content = "Ceci est un exemple de texte converti en vidéo MP4." output_mp4 = "output_file.mp4" text_to_mp4(text_content, output_mp4) pip install fpdf moviepy gtts numpy pandas scikit-learn tensorflow torch matplotlib seaborn requests flask django scrapy beautifulsoup4 lxml sqlalchemy pillow opencv-python moviepy gtts pyttsx3 fpdf reportlab docx openpyxl xlrd pytest sphinx nltk spacy gensim transformers plotly streamlit pip install -r requirements.txt pip install numpy pandas scikit-learn tensorflow torch matplotlib seaborn requests flask django scrapy beautifulsoup4 lxml sqlalchemy pillow opencv-python moviepy gtts pyttsx3 fpdf reportlab docx openpyxl xlrd pytest sphinx nltk spacy gensim transformers plotly streamlit conda install numpy pandas scikit-learn matplotlib seaborn scipy tensorflow pytorch requests flask django scrapy beautifulsoup4 lxml sqlalchemy pillow opencv moviepy nltk spacy gensim transformers plotly streamlit import subprocess import json import requests
url = "https://pypi.org/simple/" response = requests.get(url)
packages = response.text.split("\n")
for package in packages: if package: # S'assurer que la ligne n'est pas vide try: subprocess.check_call([sys.executable, "-m", "pip", "install", package]) except subprocess.CalledProcessError: print(f"Impossible d'installer {package}") pip install openai import openai
openai.api_key = "TA_CLE_API_OPENAI"
def gpt_understand_request(request): # Appel à l'API GPT-4 pour comprendre la demande response = openai.Completion.create( engine="gpt-4", # Utilise GPT-4 prompt=f"Comprends et interprète cette demande en langage naturel : {request}", max_tokens=200 # Limite le nombre de mots dans la réponse ) return response['choices'][0]['text']
user_request = "Peux-tu me donner des conseils sur la manière d'apprendre le machine learning ?" response = gpt_understand_request(user_request) print(response) pip install transformers torch from transformers import pipeline
bert_nlp = pipeline("question-answering")
def bert_understand_request(question, context): # Utiliser BERT pour comprendre la question et trouver une réponse result = bert_nlp(question=question, context=context) return result['answer']
context = """ Le machine learning est un sous-domaine de l'intelligence artificielle qui consiste à utiliser des algorithmes et des techniques statistiques pour permettre aux machines d'apprendre à partir des données. """ user_question = "Qu'est-ce que le machine learning ?" response = bert_understand_request(user_question, context) print(response) import openai from transformers import pipeline
openai.api_key = "TA_CLE_API_OPENAI" bert_nlp = pipeline("question-answering")
def gpt_understand_request(request):
response = openai.Completion.create(
engine="gpt-4",
prompt=f"Comprends cette demande en langage naturel et génère une réponse appropriée : {request}",
max_tokens=200
)
return response['choices'][0]['text']
def bert_understand_request(question, context): result = bert_nlp(question=question, context=context) return result['answer']
def handle_user_request(request, context): # Interpréter la demande avec GPT gpt_response = gpt_understand_request(request)
# Utiliser la réponse GPT comme question pour BERT, avec un contexte
bert_response = bert_understand_request(gpt_response, context)
return bert_response
user_request = "Comment puis-je commencer à apprendre l'intelligence artificielle ?" context = """ L'intelligence artificielle est un domaine vaste qui implique l'apprentissage automatique, la vision par ordinateur, le traitement du langage naturel... """ response = handle_user_request(user_request, context) print(response) import requests
bing_api_key = "TA_CLE_API_BING"
def bing_search(query): search_url = "https://api.bing.microsoft.com/v7.0/search" headers = {"Ocp-Apim-Subscription-Key": bing_api_key} params = {"q": query, "textDecorations": True, "textFormat": "HTML"}
# Envoyer la requête à l'API Bing
response = requests.get(search_url, headers=headers, params=params)
# Vérifier si la requête est réussie
if response.status_code == 200:
return response.json() # Retourner les résultats de la recherche
else:
print("Erreur dans la requête Bing :", response.status_code)
return None
query = "Apprendre le machine learning" search_results = bing_search(query)
if search_results: for result in search_results["webPages"]["value"]: print(f"Title: {result['name']}") print(f"URL: {result['url']}") print(f"Description: {result['snippet']}") print("-" * 80) pip install requests beautifulsoup4 import requests from bs4 import BeautifulSoup
def scrape_website(url): # Envoyer une requête GET pour obtenir le contenu de la page response = requests.get(url)
# Vérifier si la requête est réussie
if response.status_code == 200:
# Parser le contenu HTML avec BeautifulSoup
soup = BeautifulSoup(response.text, 'html.parser')
# Extraire le titre de la page
title = soup.title.string
print(f"Title: {title}")
# Extraire et afficher les paragraphes de texte
paragraphs = soup.find_all('p')
for p in paragraphs[:5]: # Limiter à 5 paragraphes
print(p.text)
print("-" * 80)
else:
print("Erreur lors de la requête :", response.status_code)
url = "https://fr.wikipedia.org/wiki/Apprentissage_automatique" scrape_website(url) import requests from bs4 import BeautifulSoup
bing_api_key = "TA_CLE_API_BING"
def bing_search(query): search_url = "https://api.bing.microsoft.com/v7.0/search" headers = {"Ocp-Apim-Subscription-Key": bing_api_key} params = {"q": query, "textDecorations": True, "textFormat": "HTML"}
response = requests.get(search_url, headers=headers, params=params)
if response.status_code == 200:
return response.json() # Retourner les résultats de la recherche
else:
print("Erreur dans la requête Bing :", response.status_code)
return None
def scrape_website(url): response = requests.get(url) if response.status_code == 200: soup = BeautifulSoup(response.text, 'html.parser') title = soup.title.string paragraphs = soup.find_all('p') return title, [p.text for p in paragraphs[:3]] # Limiter à 3 paragraphes else: return None, None
query = "Apprentissage automatique" search_results = bing_search(query)
if search_results: for result in search_results["webPages"]["value"][:3]: # Limiter à 3 résultats print(f"Scraping URL: {result['url']}") title, content = scrape_website(result['url']) if title: print(f"Title: {title}") for paragraph in content: print(paragraph) print("-" * 80) import requests
google_api_key = "TA_CLE_API_GOOGLE" cx = "ID_MOTEUR_DE_RECHERCHE_PERSONNALISÉ"
def google_search(query): search_url = f"https://www.googleapis.com/customsearch/v1" params = { "key": google_api_key, "cx": cx, "q": query }
response = requests.get(search_url, params=params)
if response.status_code == 200:
return response.json()
else:
print("Erreur dans la requête Google Search :", response.status_code)
return None
query = "Apprendre l'IA" search_results = google_search(query)
if search_results: for item in search_results['items'][:3]: # Limiter à 3 résultats print(f"Title: {item['title']}") print(f"Link: {item['link']}") print(f"Snippet: {item['snippet']}") print("-" * 80) import requests from datetime import datetime
search_results = [ { "title": "Introduction au Machine Learning", "url": "https://example.com/ml-introduction", "authority": "Expert", "publication_date": "2023-05-10", "snippet": "Une introduction complète aux concepts de machine learning.", }, { "title": "Article de blog sur le ML", "url": "https://example.com/blog-ml", "authority": "Blog personnel", "publication_date": "2022-10-15", "snippet": "Mon expérience avec le machine learning.", }, { "title": "Guide du Machine Learning", "url": "https://example.com/ml-guide", "authority": "Site éducatif", "publication_date": "2023-01-20", "snippet": "Un guide détaillé sur le machine learning.", }, ]
def evaluate_source(source): authority_score = 0 relevance_score = 0
# Évaluation de l'autorité de la source
if source['authority'] == "Expert":
authority_score += 2
elif source['authority'] == "Site éducatif":
authority_score += 1
else:
authority_score += 0
# Évaluation de la date de publication
publication_date = datetime.strptime(source['publication_date'], "%Y-%m-%d")
days_since_publication = (datetime.now() - publication_date).days
if days_since_publication <= 30: # Récemment publié
relevance_score += 2
elif days_since_publication <= 365: # Publié dans la dernière année
relevance_score += 1
else:
relevance_score += 0
# Score total
total_score = authority_score + relevance_score
return total_score
def filter_sources(results, threshold=2): filtered_sources = []
for result in results:
score = evaluate_source(result)
if score >= threshold:
filtered_sources.append(result)
return filtered_sources
filtered_results = filter_sources(search_results)
print("Résultats filtrés :") for source in filtered_results: print(f"Title: {source['title']}") print(f"URL: {source['url']}") print(f"Authority: {source['authority']}") print(f"Publication Date: {source['publication_date']}") print(f"Snippet: {source['snippet']}") print("-" * 80) import requests
openai_api_key = "TA_CLE_API_OPENAI"
def generate_document(information): # Préparer la requête pour l'API GPT prompt = f"À partir des informations suivantes, génère un document structuré :\n\n{information}\n\nDocument structuré :"
response = requests.post(
"https://api.openai.com/v1/completions",
headers={
"Authorization": f"Bearer {openai_api_key}",
"Content-Type": "application/json"
},
json={
"model": "gpt-4", # Utiliser le modèle GPT-4
"prompt": prompt,
"max_tokens": 500, # Limite des mots dans la réponse
"temperature": 0.7 # Contrôle la créativité de la réponse
}
)
# Vérifier si la requête est réussie
if response.status_code == 200:
return response.json()['choices'][0]['text'].strip()
else:
print("Erreur dans la requête OpenAI :", response.status_code)
return None
information = """
- Le machine learning est une sous-discipline de l'intelligence artificielle qui utilise des algorithmes pour permettre aux ordinateurs d'apprendre à partir de données.
- Il existe plusieurs types d'apprentissage, notamment l'apprentissage supervisé, non supervisé et par renforcement.
- Les applications du machine learning incluent la reconnaissance d'image, le traitement du langage naturel et les systèmes de recommandation. """
structured_document = generate_document(information)
if structured_document: print("Document structuré généré :") print(structured_document) pip install reportlab from reportlab.lib.pagesizes import letter from reportlab.pdfgen import canvas
def generate_pdf(filename, content): # Créer un objet canvas c = canvas.Canvas(filename, pagesize=letter)
# Définir le titre
c.setFont("Helvetica-Bold", 16)
c.drawString(100, 750, "Document Structuré")
# Définir le contenu
c.setFont("Helvetica", 12)
y = 720 # Position Y pour le texte
for line in content.split('\n'):
c.drawString(100, y, line)
y -= 20 # Espace entre les lignes
# Sauvegarder le PDF
c.save()
content = """1. Le machine learning est une sous-discipline de l'intelligence artificielle. 2. Il existe plusieurs types d'apprentissage : supervisé, non supervisé et par renforcement. 3. Les applications incluent la reconnaissance d'image, le traitement du langage naturel et les systèmes de recommandation."""
generate_pdf("document_structuré.pdf", content) print("PDF généré avec succès : document_structuré.pdf") pip install pdfkit brew install wkhtmltopdf sudo apt-get install wkhtmltopdf import pdfkit
html_content = """
<title>Document Structuré</title>- Le machine learning est une sous-discipline de l'intelligence artificielle.
- Il existe plusieurs types d'apprentissage : supervisé, non supervisé et par renforcement.
- Les applications incluent la reconnaissance d'image, le traitement du langage naturel et les systèmes de recommandation.
pdfkit.from_string(html_content, 'document_structuré.pdf')
print("PDF généré avec succès : document_structuré.pdf") pip install moviepy from moviepy.editor import ImageClip, concatenate_videoclips, AudioFileClip
def create_video(image_files, audio_file, output_file): # Créer des clips d'image clips = [] for image_file in image_files: # Créer un clip pour chaque image clip = ImageClip(image_file).set_duration(2) # Durée de chaque image : 2 secondes clips.append(clip)
# Concatenate les clips
video = concatenate_videoclips(clips, method="compose")
# Ajouter de l'audio si spécifié
if audio_file:
audio = AudioFileClip(audio_file)
video = video.set_audio(audio)
# Écrire la vidéo finale sur le disque
video.write_videofile(output_file, fps=24)
image_files = ["image1.jpg", "image2.jpg", "image3.jpg"] # Remplace avec tes fichiers d'images audio_file = "audio.mp3" # Remplace avec ton fichier audio output_file = "video_finale.mp4"
create_video(image_files, audio_file, output_file) print("Vidéo générée avec succès : video_finale.mp4") pip install gTTS playsound from gtts import gTTS import os from playsound import playsound
def generate_voice_over(text, language='fr', filename='voice_over.mp3'): # Créer l'objet gTTS tts = gTTS(text=text, lang=language, slow=False)
# Sauvegarder le fichier audio
tts.save(filename)
# Lire le fichier audio
playsound(filename)
text = "Bonjour, ceci est une voix off générée par Google Text-to-Speech."
generate_voice_over(text) print("Voix off générée avec succès : voice_over.mp3") pip install azure-cognitiveservices-speech import azure.cognitiveservices.speech as speechsdk
def generate_voice_over_azure(text, subscription_key, region, filename='voice_over.wav'): # Créer un objet de configuration speech_config = speechsdk.SpeechConfig(subscription=subscription_key, region=region)
# Créer un synthétiseur de parole
audio_config = speechsdk.audio.AudioOutputConfig(filename=filename)
synthesizer = speechsdk.SpeechSynthesizer(speech_config=speech_config, audio_config=audio_config)
# Synthétiser le texte
result = synthesizer.speak_text(text)
# Vérifier le résultat
if result.reason == speechsdk.ResultReason.SynthesizingAudioCompleted:
print("Voix off générée avec succès : " + filename)
else:
print("Erreur lors de la génération de la voix off : " + result.reason)
text = "Bonjour, ceci est une voix off générée par Microsoft Azure Speech Service."
subscription_key = "VOTRE_CLE_D_API" region = "VOTRE_REGION"
generate_voice_over_azure(text, subscription_key, region) brew install ffmpeg sudo apt-get install ffmpeg from PIL import Image, ImageDraw
def create_image(filename, text): # Créer une image blanche img = Image.new('RGB', (640, 480), color = 'white') d = ImageDraw.Draw(img)
# Ajouter du texte
d.text((10, 10), text, fill=(0, 0, 0))
# Sauvegarder l'image
img.save(filename)
for i in range(1, 6): create_image(f"image{i}.png", f"Image {i}")
print("Images créées avec succès.") sudo apt-get install texlive-full import os
def generate_latex_pdf(content, filename='document.tex'): # Créer le contenu LaTeX latex_content = r""" \documentclass{article} \usepackage[utf8]{inputenc} \usepackage{amsmath} \usepackage{graphicx}
\title{Mon Document}
\author{Auteur}
\date{\today}
\begin{document}
\maketitle
\section{Introduction}
Ce document est généré avec LaTeX.
\section{Contenu}
""" + content + r"""
\end{document}
"""
# Écrire le contenu dans un fichier .tex
with open(filename, 'w') as f:
f.write(latex_content)
# Compiler le fichier LaTeX en PDF
os.system(f"pdflatex {filename}")
content = """ Voici un exemple de contenu dans ce document. Vous pouvez ajouter plus de détails ici. """
generate_latex_pdf(content) print("PDF généré avec succès.") pip install WeasyPrint from weasyprint import HTML
def generate_pdf_with_weasyprint(html_content, filename='document.pdf'): # Créer un document PDF à partir du contenu HTML HTML(string=html_content).write_pdf(filename) print(f"PDF généré avec succès : {filename}")
html_content = """
<title>Mon Document</title> <style> body { font-family: Arial, sans-serif; } h1 { color: navy; } p { margin: 10px 0; } </style>Ceci est un document généré avec WeasyPrint.
Vous pouvez ajouter du texte et des images comme bon vous semble.
"""generate_pdf_with_weasyprint(html_content) ffmpeg -framerate 1 -i image%d.png -i audio.mp3 -c:v libx264 -c:a aac -strict experimental -b:a 192k -vf "fps=25,format=yuv420p" output.mp4 import subprocess
def create_video(images, audio_file, output_file='output.mp4', framerate=1): # Commande FFmpeg command = [ 'ffmpeg', '-framerate', str(framerate), '-i', images, '-i', audio_file, '-c:v', 'libx264', '-c:a', 'aac', '-strict', 'experimental', '-b:a', '192k', '-vf', 'fps=25,format=yuv420p', output_file ]
# Exécution de la commande
subprocess.run(command)
print(f"Vidéo générée avec succès : {output_file}")
create_video('image%d.png', 'audio.mp3') pip install requests beautifulsoup4 gTTS WeasyPrint transformers import requests from bs4 import BeautifulSoup from gtts import gTTS from weasyprint import HTML import subprocess import os
def understand_user_request(request): # Ici, on pourrait utiliser un modèle NLP pour analyser la demande # Pour cet exemple, on suppose simplement que la demande est un mot clé return request.strip()
def search_information(keyword): # Effectuer une recherche sur Google (exemple simplifié) url = f"https://www.google.com/search?q={keyword}" headers = {'User-Agent': 'Mozilla/5.0'}
response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text, 'html.parser')
# Extraire les titres des résultats
results = []
for item in soup.find_all('h3'):
results.append(item.get_text())
return results[:5] # Retourne les 5 premiers résultats
def generate_voice(content): tts = gTTS(text=content, lang='fr', slow=False) tts.save('voice.mp3')
def generate_pdf(content): html_content = f"
{content}
" HTML(string=html_content).write_pdf('output.pdf')def create_video(images, audio_file, output_file='output.mp4'): command = [ 'ffmpeg', '-framerate', '1', '-i', images, '-i', audio_file, '-c:v', 'libx264', '-c:a', 'aac', '-strict', 'experimental', '-b:a', '192k', '-vf', 'fps=25,format=yuv420p', output_file ] subprocess.run(command)
def main(user_request): # 1. Comprendre la demande keyword = understand_user_request(user_request)
# 2. Effectuer des recherches
search_results = search_information(keyword)
results_text = "\n".join(search_results)
# 3. Générer du contenu
generate_voice(results_text)
generate_pdf(results_text)
# Supposons que nous avons des images nommées image1.png, image2.png, ...
create_video('image%d.png', 'voice.mp3')
print("Processus d'automatisation terminé.")
user_input = "Recherche d'informations sur l'intelligence artificielle" main(user_input) pip install tensorflow torch torchvision moviepy reportlab import numpy as np import tensorflow as tf import torch import torchvision.transforms as transforms from moviepy.editor import ImageSequenceClip from reportlab.lib.pagesizes import letter from reportlab.pdfgen import canvas
def tensorflow_example(): # Exemple simple d'un modèle TensorFlow model = tf.keras.Sequential([ tf.keras.layers.Dense(10, activation='relu', input_shape=(784,)), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) print("Modèle TensorFlow créé avec succès.")
def pytorch_example(): # Exemple simple d'un modèle PyTorch class SimpleModel(torch.nn.Module): def init(self): super(SimpleModel, self).init() self.fc1 = torch.nn.Linear(784, 10) self.fc2 = torch.nn.Linear(10, 10)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
model = SimpleModel()
print("Modèle PyTorch créé avec succès.")
def create_video(images, output_file='output_video.mp4'): clip = ImageSequenceClip(images, fps=24) clip.write_videofile(output_file) print(f"Vidéo créée : {output_file}")
def create_pdf(text_content, output_file='output.pdf'): c = canvas.Canvas(output_file, pagesize=letter) c.drawString(100, 750, text_content) c.save() print(f"PDF créé : {output_file}")
def main(): # 1. Exemple d'utilisation de TensorFlow tensorflow_example()
# 2. Exemple d'utilisation de PyTorch
pytorch_example()
# 3. Créer une vidéo à partir d'images
create_video(['image1.png', 'image2.png', 'image3.png'])
# 4. Créer un PDF
create_pdf("Ceci est un exemple de contenu dans un PDF.", "example.pdf")
if name == "main": main() pip install transformers torch openai from transformers import GPT2LMHeadModel, GPT2Tokenizer
def generate_text_huggingface(prompt, max_length=100): # Chargement du modèle et du tokenizer tokenizer = GPT2Tokenizer.from_pretrained("gpt2") model = GPT2LMHeadModel.from_pretrained("gpt2")
# Préparation du prompt
inputs = tokenizer.encode(prompt, return_tensors="pt")
# Génération de texte
outputs = model.generate(inputs, max_length=max_length, num_return_sequences=1)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
return generated_text
prompt = "Une fois, dans un royaume lointain" generated_text = generate_text_huggingface(prompt) print("Texte généré (Hugging Face):") print(generated_text) import openai
def generate_text_openai(prompt): # Assure-toi d'utiliser ta clé API ici openai.api_key = 'YOUR_OPENAI_API_KEY'
response = openai.Completion.create(
engine="text-davinci-003", # Tu peux choisir le modèle que tu veux
prompt=prompt,
max_tokens=100
)
return response.choices[0].text.strip()
prompt = "Une fois, dans un royaume lointain" generated_text = generate_text_openai(prompt) print("Texte généré (OpenAI GPT-3):") print(generated_text) import requests
def google_search(query, api_key, search_engine_id): url = f"https://www.googleapis.com/customsearch/v1" params = { 'q': query, 'key': api_key, 'cx': search_engine_id }
response = requests.get(url, params=params)
if response.status_code == 200:
results = response.json()
return results.get('items', [])
else:
print(f"Erreur: {response.status_code} - {response.text}")
return []
API_KEY = 'YOUR_GOOGLE_API_KEY' # Remplace par ta clé API SEARCH_ENGINE_ID = 'YOUR_SEARCH_ENGINE_ID' # Remplace par ton ID de moteur de recherche
results = google_search("intelligence artificielle", API_KEY, SEARCH_ENGINE_ID) for item in results: print(f"Titre: {item['title']}") print(f"Lien: {item['link']}\n") import requests
def bing_search(query, api_key): url = "https://api.bing.microsoft.com/v7.0/search" headers = { 'Ocp-Apim-Subscription-Key': api_key } params = { 'q': query, 'textDecorations': True, 'textFormat': 'HTML' }
response = requests.get(url, headers=headers, params=params)
if response.status_code == 200:
results = response.json()
return results.get('webPages', {}).get('value', [])
else:
print(f"Erreur: {response.status_code} - {response.text}")
return []
API_KEY = 'YOUR_BING_API_KEY' # Remplace par ta clé API
results = bing_search("intelligence artificielle", API_KEY) for item in results: print(f"Titre: {item['name']}") print(f"Lien: {item['url']}\n") pip install moviepy gTTS from moviepy.editor import * from gtts import gTTS import os
def create_voice_over(text, filename='voiceover.mp3'): # Générer la voix off à partir du texte tts = gTTS(text=text, lang='fr') tts.save(filename) print(f"Voix off enregistrée : {filename}")
def create_video(images, audio_file, output_file='output_video.mp4'): # Charger les images dans un clip vidéo clips = [ImageClip(img).set_duration(2) for img in images] # Chaque image affichée pendant 2 secondes video = concatenate_videoclips(clips, method="compose")
# Ajouter l'audio à la vidéo
audio = AudioFileClip(audio_file)
video = video.set_audio(audio)
# Écrire le fichier de sortie
video.write_videofile(output_file, fps=24)
print(f"Vidéo créée : {output_file}")
def main(): # 1. Créer la voix off text = "Bienvenue dans notre vidéo sur l'intelligence artificielle." create_voice_over(text)
# 2. Créer une vidéo à partir d'images
images = ['image1.jpg', 'image2.jpg', 'image3.jpg'] # Remplace par tes fichiers d'images
create_video(images, 'voiceover.mp3')
if name == "main": main() pip install scikit-learn pandas import pandas as pd from sklearn.model_selection import train_test_split from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score import pickle
class AIModel: def init(self): self.model = None
def train(self, data, labels):
# Diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=42)
# Entraîner le modèle
self.model = RandomForestClassifier(n_estimators=100)
self.model.fit(X_train, y_train)
# Évaluer le modèle
predictions = self.model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print(f"Précision du modèle: {accuracy:.2f}")
def predict(self, new_data):
# Prédire avec le modèle entraîné
if self.model:
return self.model.predict(new_data)
else:
raise Exception("Le modèle n'est pas encore entraîné.")
def update_model(self, new_data, new_labels):
# Ajouter de nouvelles données et réentraîner le modèle
if self.model:
self.train(new_data, new_labels)
else:
raise Exception("Le modèle n'est pas encore entraîné.")
def save_model(self, filename):
with open(filename, 'wb') as f:
pickle.dump(self.model, f)
print(f"Modèle sauvegardé sous: {filename}")
def load_model(self, filename):
with open(filename, 'rb') as f:
self.model = pickle.load(f)
print(f"Modèle chargé depuis: {filename}")
def main(): # Créer une instance du modèle ai_model = AIModel()
# Simuler des données d'entraînement
# Exemple: 100 exemples avec 5 caractéristiques
data = pd.DataFrame({
'feature1': [1, 2, 3, 4, 5] * 20,
'feature2': [5, 4, 3, 2, 1] * 20,
'feature3': [1, 1, 2, 2, 3] * 20,
'feature4': [0, 1, 0, 1, 0] * 20,
'feature5': [1, 0, 1, 0, 1] * 20,
})
labels = [0, 1, 0, 1, 1] * 20 # Labels binaires
# Entraîner le modèle initial
ai_model.train(data, labels)
# Simuler de nouvelles données et retours utilisateurs
new_data = pd.DataFrame({
'feature1': [2, 3, 4],
'feature2': [3, 2, 1],
'feature3': [2, 2, 1],
'feature4': [1, 0, 1],
'feature5': [0, 1, 0],
})
new_labels = [1, 0, 1] # Nouvelles étiquettes
# Mettre à jour le modèle avec les nouvelles données
ai_model.update_model(new_data, new_labels)
# Sauvegarder le modèle
ai_model.save_model("ai_model.pkl")
# Charger le modèle
ai_model.load_model("ai_model.pkl")
# Faire une prédiction avec de nouvelles données
predictions = ai_model.predict(new_data)
print("Prédictions sur de nouvelles données:", predictions)
if name == "main": main() from fpdf import FPDF
def generate_pdf(content, file_name="output.pdf"): pdf = FPDF() pdf.add_page() pdf.set_font("Arial", size=12)
for line in content:
pdf.cell(200, 10, txt=line, ln=True)
pdf.output(file_name)
content = [ "Titre: Découvertes récentes en physique quantique", "1. Découverte du boson de Higgs", "2. Améliorations des ordinateurs quantiques" ]
generate_pdf(content)