pvharmo2/gha-lab-6255f5fc33सुरक्षा-अनुसंधान प्रयोगशाला जो CVE-2023-6572 (GHSA-gqvf-3hgp-5hxv) को पुनरुत्पादित करती है: gradio-app/gradio के workflow_run में generate-changeset.yml की हैंडलिंग में कमांड इंजेक्शन
स्वचालित शोध आर्टिफैक्ट — अपस्ट्रीम प्रोजेक्ट नहीं।
यह रिपोर्टिटरी एक डिस्पोज़ेबल लैब है जिसे Université Laval में मास्टर थीसिस के लिए एक स्वचालित हार्नेस द्वारा बनाया गया है, जिसका उद्देश्य प्रकाशित GitHub Actions वर्कफ़्लो कमज़ोरियों को पुनः प्रस्तुत करना है। यह
gradio-app/gradioका एक शब्दशः स्नैपशॉट है जो कमिट1d986217f6f4fc1829e528d2afe365635788204f(2023-11-03) पर है, जिसे उस प्रोजेक्ट के अपने लाइसेंस के तहत पुनर्वितरित किया गया है, जिसकी फ़ाइल इस स्नैपशॉट में अपरिवर्तित शामिल है।अपस्ट्रीम प्रोजेक्ट शामिल नहीं है, उसे कभी लक्षित नहीं किया जाता है, और यहाँ अध्ययन की गई कमज़ोरी पहले से ही सार्वजनिक है। इस रिपोर्टिटरी में हर सीक्रेट और वेरिएबल एक यादृच्छिक रूप से उत्पन्न डमी मान है — कोई वास्तविक क्रेडेंशियल मौजूद नहीं है। एक्शन संदर्भ और रनर इमेज उसी पर पिन किए गए हैं जो 2023-11-03 को हल हुए थे; स्नैपशॉट में किए गए हर बदलाव के लिए हार्नेस आउटपुट में
pinning.mdदेखें।प्रश्न या आपत्तियाँ: [email protected]
Website | Documentation | Guides | Getting Started | Examples | 中文
Gradio एक ओपन-सोर्स Python लाइब्रेरी है जिसका उपयोग मशीन लर्निंग और डेटा साइंस डेमो और वेब एप्लिकेशन बनाने के लिए किया जाता है।
Gradio के साथ, आप अपने मशीन लर्निंग मॉडल या डेटा साइंस वर्कफ़्लो के चारों ओर जल्दी से एक सुंदर यूज़र इंटरफ़ेस बना सकते हैं और लोगों को अपनी छवियों को ड्रैग-एंड-ड्रॉप करके, टेक्स्ट पेस्ट करके, अपनी आवाज़ रिकॉर्ड करके, और आपके डेमो के साथ इंटरैक्ट करके "इसे आज़माने" दें — यह सब ब्राउज़र के माध्यम से।
Gradio निम्नलिखित के लिए उपयोगी है:
डेमो — अपने मशीन लर्निंग मॉडल को क्लाइंट/सहयोगियों/उपयोगकर्ताओं/छात्रों के लिए प्रदर्शित करना।
डिप्लॉय — स्वचालित साझा करने योग्य लिंक के साथ अपने मॉडल को जल्दी से तैनात करना और मॉडल प्रदर्शन पर फीडबैक प्राप्त करना।
डीबगिंग — विकास के दौरान अंतर्निहित इनपुट मैनिपुलेशन टूल का उपयोग करके अपने मॉडल को इंटरैक्टिव रूप से डीबग करना।
पूर्वापेक्षा: Gradio को Python 3.8 या उच्चतर की आवश्यकता है, बस इतना ही!
अपने मशीन लर्निंग मॉडल, API, या डेटा साइंस वर्कफ़्लो को दूसरों के साथ साझा करने के सर्वोत्तम तरीकों में से एक है एक इंटरैक्टिव ऐप बनाना जो आपके उपयोगकर्ताओं या सहयोगियों को अपने ब्राउज़र में डेमो आज़माने की अनुमति देता है।
Gradio आपको डेमो बनाने और साझा करने की अनुमति देता है, सब कुछ Python में। और आमतौर पर कोड की कुछ ही पंक्तियों में! तो चलिए शुरू करते हैं।
Gradio को एक सरल "हैलो, वर्ल्ड" उदाहरण के साथ चलाने के लिए, इन तीन चरणों का पालन करें:
1. pip का उपयोग करके Gradio इंस्टॉल करें:
pip install gradio
2. नीचे दिए गए कोड को Python स्क्रिप्ट के रूप में या Jupyter Notebook (या Google Colab) में चलाएँ:
import gradio as gr
def greet(name):
return "Hello " + name + "!"
demo = gr.Interface(fn=greet, inputs="text", outputs="text")
demo.launch()
हम Gradio का उपयोग करने वाले कोड की बेहतर पठनीयता के लिए आयातित नाम को gr तक छोटा करते हैं। यह एक व्यापक रूप से अपनाया गया सम्मेलन है जिसका आपको पालन करना चाहिए ताकि आपके कोड के साथ काम करने वाला कोई भी व्यक्ति इसे आसानी से समझ सके।
3. नीचे दिया गया डेमो Jupyter Notebook के भीतर स्वचालित रूप से दिखाई देगा, या यदि स्क्रिप्ट से चल रहा है तो http://localhost:7860 पर ब्राउज़र में खुलेगा:
स्थानीय रूप से विकास करते समय, यदि आप कोड को Python स्क्रिप्ट के रूप में चलाना चाहते हैं, तो आप एप्लिकेशन को रिलोड मोड में लॉन्च करने के लिए Gradio CLI का उपयोग कर सकते हैं, जो सहज और तेज़ विकास प्रदान करेगा। रीलोडिंग के बारे में Auto-Reloading Guide में और जानें।
gradio app.py
नोट: आप python app.py भी कर सकते हैं, लेकिन यह स्वचालित रीलोड तंत्र प्रदान नहीं करेगा।
Interface क्लासआप देखेंगे कि डेमो बनाने के लिए, हमने एक gr.Interface बनाया। यह Interface क्लास किसी भी Python फ़ंक्शन को यूज़र इंटरफ़ेस के साथ लपेट सकती है। उपरोक्त उदाहरण में, हमने एक सरल टेक्स्ट-आधारित फ़ंक्शन देखा, लेकिन फ़ंक्शन संगीत जनरेटर से लेकर टैक्स कैलकुलेटर तक पूर्व-प्रशिक्षित मशीन लर्निंग मॉडल के भविष्यवाणी फ़ंक्शन तक कुछ भी हो सकता है।
कोर Interface क्लास तीन आवश्यक पैरामीटर के साथ प्रारंभ किया गया है:
fn: UI के चारों ओर लपेटने के लिए फ़ंक्शनinputs: इनपुट के लिए कौन से कंपोनेंट का उपयोग करना है (जैसे "text", "image" या "audio")outputs: आउटपुट के लिए कौन से कंपोनेंट का उपयोग करना है (जैसे "text", "image" या "label")आइए इनपुट और आउटपुट प्रदान करने के लिए उपयोग किए जाने वाले इन कंपोनेंट्स पर करीब से नज़र डालें।
हमने पिछले उदाहरणों में कुछ सरल Textbox कंपोनेंट देखे, लेकिन यदि आप UI कंपोनेंट्स के दिखने या व्यवहार को बदलना चाहते हैं तो क्या होगा?
मान लीजिए आप इनपुट टेक्स्ट फ़ील्ड को अनुकूलित करना चाहते हैं — उदाहरण के लिए, आप चाहते थे कि यह बड़ा हो और उसमें टेक्स्ट प्लेसहोल्डर हो। यदि हम स्ट्रिंग शॉर्टकट का उपयोग करने के बजाय Textbox के लिए वास्तविक क्लास का उपयोग करते हैं, तो आपके पास कंपोनेंट विशेषताओं के माध्यम से बहुत अधिक अनुकूलन क्षमता तक पहुंच होती है।
import gradio as gr
def greet(name):
return "Hello " + name + "!"
demo = gr.Interface(
fn=greet,
inputs=gr.Textbox(lines=2, placeholder="Name Here..."),
outputs="text",
)
demo.launch()
मान लीजिए आपके पास एक अधिक जटिल फ़ंक्शन था, जिसमें कई इनपुट और आउटपुट थे। नीचे दिए गए उदाहरण में, हम एक फ़ंक्शन परिभाषित करते हैं जो एक स्ट्रिंग, बूलियन और संख्या लेता है, और एक स्ट्रिंग और संख्या लौटाता है। देखें कि आप इनपुट और आउटपुट कंपोनेंट्स की सूची कैसे पास करते हैं।
import gradio as gr
def greet(name, is_morning, temperature):
salutation = "Good morning" if is_morning else "Good evening"
greeting = f"{salutation} {name}. It is {temperature} degrees today"
celsius = (temperature - 32) * 5 / 9
return greeting, round(celsius, 2)
demo = gr.Interface(
fn=greet,
inputs=["text", "checkbox", gr.Slider(0, 100)],
outputs=["text", "number"],
)
demo.launch()
आप बस कंपोनेंट्स को एक सूची में लपेटते हैं। inputs सूची में प्रत्येक कंपोनेंट फ़ंक्शन के पैरामीटर में से एक के अनुरूप होता है, क्रम में। outputs सूची में प्रत्येक कंपोनेंट फ़ंक्शन द्वारा लौटाए गए मानों में से एक के अनुरूप होता है, फिर से क्रम में।
Gradio कई प्रकार के कंपोनेंट्स का समर्थन करता है, जैसे Image, DataFrame, Video, या Label। आइए इनकी समझ पाने के लिए एक इमेज-टू-इमेज फ़ंक्शन आज़माएँ!
import numpy as np
import gradio as gr
def sepia(input_img):
sepia_filter = np.array([
[0.393, 0.769, 0.189],
[0.349, 0.686, 0.168],
[0.272, 0.534, 0.131]
])
sepia_img = input_img.dot(sepia_filter.T)
sepia_img /= sepia_img.max()
return sepia_img
demo = gr.Interface(sepia, gr.Image(width=200, height=200), "image")
demo.launch()
Image कंपोनेंट को इनपुट के रूप में उपयोग करते समय, आपका फ़ंक्शन आकार (height, width, 3) के साथ एक NumPy ऐरे प्राप्त करेगा, जहाँ अंतिम आयाम RGB मानों का प्रतिनिधित्व करता है। हम NumPy ऐरे के रूप में एक छवि भी लौटाएंगे।
आप type= कीवर्ड तर्क के साथ कंपोनेंट द्वारा उपयोग किए जाने वाले डेटाटाइप को भी सेट कर सकते हैं। उदाहरण के लिए, यदि आप चाहते थे कि आपका फ़ंक्शन NumPy ऐरे के बजाय छवि का फ़ाइल पथ ले, तो इनपुट Image कंपोनेंट इस प्रकार लिखा जा सकता है:
gr.Image(type="filepath", shape=...)
यह भी ध्यान दें कि हमारे इनपुट Image कंपोनेंट में एक संपादन बटन 🖉 है, जो छवियों को क्रॉप करने और ज़ूम करने की अनुमति देता है। इस तरह से छवियों को हेरफेर करने से मशीन लर्निंग मॉडल में पूर्वाग्रह या छिपी हुई खामियों को उजागर करने में मदद मिल सकती है!
आप कई कंपोनेंट्स और उन्हें उपयोग करने के तरीके के बारे में Gradio docs में अधिक पढ़ सकते हैं।
Gradio में एक उच्च-स्तरीय क्लास, gr.ChatInterface शामिल है, जो gr.Interface के समान है, लेकिन विशेष रूप से चैटबॉट UI के लिए डिज़ाइन किया गया है। gr.ChatInterface क्लास भी एक फ़ंक्शन लपेटता है लेकिन इस फ़ंक्शन का एक विशिष्ट हस्ताक्षर होना चाहिए। फ़ंक्शन को दो तर्क लेने चाहिए: message और फिर history (तर्कों का नाम कुछ भी हो सकता है, लेकिन इस क्रम में होना चाहिए)
message: उपयोगकर्ता के इनपुट का प्रतिनिधित्व करने वाला एक strhistory: उस बिंदु तक की बातचीत का प्रतिनिधित्व करने वाली list की list। प्रत्येक आंतरिक सूची में एक जोड़ी का प्रतिनिधित्व करने वाले दो str होते हैं: [user input, bot response]।आपके फ़ंक्शन को एक एकल स्ट्रिंग प्रतिक्रिया लौटानी चाहिए, जो विशेष उपयोगकर्ता इनपुट message के लिए बॉट की प्रतिक्रिया है।
इसके अलावा, gr.ChatInterface का कोई आवश्यक पैरामीटर नहीं है (हालांकि UI के अनुकूलन के लिए कई उपलब्ध हैं)।
यहाँ एक खिलौना उदाहरण है:
import random
import gradio as gr
def random_response(message, history):
return random.choice(["Yes", "No"])
demo = gr.ChatInterface(random_response)
demo.launch()
Gradio ऐप्स बनाने के लिए दो दृष्टिकोण प्रदान करता है:
1. Interface और ChatInterface, जो अब तक चर्चा किए गए डेमो बनाने के लिए उच्च-स्तरीय अमूर्तता प्रदान करते हैं।
2. Blocks, अधिक लचीले लेआउट और डेटा फ़्लो के साथ वेब ऐप्स डिज़ाइन करने के लिए एक निम्न-स्तरीय API। Blocks आपको कई डेटा फ़्लो और डेमो दिखाने, पेज पर कंपोनेंट्स कहाँ दिखाई देते हैं यह नियंत्रित करने, जटिल डेटा फ़्लो संभालने (जैसे आउटपुट अन्य फ़ंक्शन के इनपुट के रूप में काम कर सकते हैं), और उपयोगकर्ता इंटरैक्शन के आधार पर कंपोनेंट्स के गुण/दृश्यता अपडेट करने जैसी चीज़ें करने की अनुमति देता है — यह सब अभी भी Python में। यदि यह अनुकूलन क्षमता आपको चाहिए, तो Blocks आज़माएँ!
आइए एक सरल उदाहरण देखें। ध्यान दें कि यहाँ API Interface से कैसे भिन्न है।
import gradio as gr
def greet(name):
return "Hello " + name + "!"
with gr.Blocks() as demo:
name = gr.Textbox(label="Name")
output = gr.Textbox(label="Output Box")
greet_btn = gr.Button("Greet")
greet_btn.click(fn=greet, inputs=name, outputs=output, api_name="greet")
demo.launch()
ध्यान देने योग्य बातें:
Blocks एक with क्लॉज़ के साथ बनाए जाते हैं, और इस क्लॉज़ के अंदर बनाया गया कोई भी कंपोनेंट स्वचालित रूप से ऐप में जोड़ दिया जाता है।Button बनाया गया था, और फिर इस बटन में एक click इवेंट-लिसनर जोड़ा गया था। इसके लिए API परिचित दिखना चाहिए! Interface की तरह, click विधि एक Python फ़ंक्शन, इनपुट कंपोनेंट्स और आउटपुट कंपोनेंट्स लेती है।यहाँ एक ऐप है जो आपको Blocks के साथ संभव चीज़ों का स्वाद देता है:
import numpy as np
import gradio as gr
def flip_text(x):
return x[::-1]
def flip_image(x):
return np.fliplr(x)
with gr.Blocks() as demo:
gr.Markdown("Flip text or image files using this demo.")
with gr.Tab("Flip Text"):
text_input = gr.Textbox()
text_output = gr.Textbox()
text_button = gr.Button("Flip")
with gr.Tab("Flip Image"):
with gr.Row():
image_input = gr.Image()
image_output = gr.Image()
image_button = gr.Button("Flip")
with gr.Accordion("Open for More!"):
gr.Markdown("Look at me...")
text_button.click(flip_text, inputs=text_input, outputs=text_output)
image_button.click(flip_image, inputs=image_input, outputs=image_output)
demo.launch()
यहाँ बहुत कुछ चल रहा है! हम building with blocks अनुभाग में आपके लिए इस तरह के जटिल Blocks ऐप्स बनाने का तरीका कवर करेंगे।
बधाई हो, अब आप Gradio की मूल बातों से परिचित हैं! 🥳 Gradio की प्रमुख विशेषताओं के बारे में अधिक जानने के लिए हमारे अगले गाइड पर जाएँ।
Gradio कई अद्भुत ओपन-सोर्स लाइब्रेरीज़ के साथ बनाया गया है, कृपया उन्हें भी समर्थन दें!
Gradio इस रिपोर्टिटरी की रूट डायरेक्टरी में LICENSE फ़ाइल में पाए जाने वाले Apache License 2.0 के तहत लाइसेंस प्राप्त है।
पेपर Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild, ICML HILL 2019 भी देखें, और यदि आप अपने काम में Gradio का उपयोग करते हैं तो कृपया इसे उद्धृत करें।
@article{abid2019gradio,
title = {Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild},
author = {Abid, Abubakar and Abdalla, Ali and Abid, Ali and Khan, Dawood and Alfozan, Abdulrahman and Zou, James},
journal = {arXiv preprint arXiv:1906.02569},
year = {2019},
}