Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· OpenAIAi2 WildChat-4.8M (AI2)

i want to modifie this code : import gradio as gr import os import sys import json…

  1. User

    i want to modifie this code : import gradio as gr import os import sys import json import requests

    MODEL = "gpt-3.5-turbo" API_URL = os.getenv("API_URL") DISABLED = os.getenv("DISABLED") == 'True' OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") NUM_THREADS = int(os.getenv("NUM_THREADS"))

    print (NUM_THREADS)

    def exception_handler(exception_type, exception, traceback): print("%s: %s" % (exception_type.name, exception)) sys.excepthook = exception_handler sys.tracebacklimit = 0

    #https://github.com/gradio-app/gradio/issues/3531#issuecomment-1484029099 def parse_codeblock(text): lines = text.split("\n") for i, line in enumerate(lines): if "" in line: if line != "": lines[i] = f'' else: lines[i] = '' else: if i > 0: lines[i] = "" + line.replace("<", "<").replace(">", ">") return "".join(lines)

    def predict(inputs, top_p, temperature, chat_counter, chatbot, history, request:gr.Request): payload = { "model": MODEL, "messages": [{"role": "user", "content": f"{inputs}"}], "temperature" : 1.0, "top_p":1.0, "n" : 1, "stream": True, "presence_penalty":0, "frequency_penalty":0, }

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {OPENAI_API_KEY}",
        "Headers": f"{request.kwargs['headers']}"
    }
    
    # print(f"chat_counter - {chat_counter}")
    if chat_counter != 0 :
        messages = []
        for i, data in enumerate(history):
            if i % 2 == 0:
                role = 'user'
            else:
                role = 'assistant'
            message = {}
            message["role"] = role
            message["content"] = data
            messages.append(message)
        
        message = {}
        message["role"] = "user" 
        message["content"] = inputs
        messages.append(message)
        payload = {
            "model": MODEL,
            "messages": messages,
            "temperature" : temperature,
            "top_p": top_p,
            "n" : 1,
            "stream": True,
            "presence_penalty":0,
            "frequency_penalty":0,
        }
    
    chat_counter += 1
    
    history.append(inputs)
    token_counter = 0 
    partial_words = "" 
    counter = 0
    
    try:
        # make a POST request to the API endpoint using the requests.post method, passing in stream=True
        response = requests.post(API_URL, headers=headers, json=payload, stream=True)
        response_code = f"{response}"
        #if response_code.strip() != "<Response [200]>":
        #    #print(f"response code - {response}")
        #    raise Exception(f"Sorry, hitting rate limit. Please try again later. {response}")
        
        for chunk in response.iter_lines():
            #Skipping first chunk
            if counter == 0:
                counter += 1
                continue
                #counter+=1
            # check whether each line is non-empty
            if chunk.decode() :
                chunk = chunk.decode()
                # decode each line as response data is in bytes
                if len(chunk) > 12 and "content" in json.loads(chunk[6:])['choices'][0]['delta']:
                    partial_words = partial_words + json.loads(chunk[6:])['choices'][0]["delta"]["content"]
                    if token_counter == 0:
                        history.append(" " + partial_words)
                    else:
                        history[-1] = partial_words
                    token_counter += 1
                    yield [(parse_codeblock(history[i]), parse_codeblock(history[i + 1])) for i in range(0, len(history) - 1, 2) ], history, chat_counter, response, gr.update(interactive=False), gr.update(interactive=False)  # resembles {chatbot: chat, state: history}  
    except Exception as e:
        print (f'error found: {e}')
    yield [(parse_codeblock(history[i]), parse_codeblock(history[i + 1])) for i in range(0, len(history) - 1, 2) ], history, chat_counter, response, gr.update(interactive=True), gr.update(interactive=True)
    print(json.dumps({"chat_counter": chat_counter, "payload": payload, "partial_words": partial_words, "token_counter": token_counter, "counter": counter}))
                   
    

    def reset_textbox(): return gr.update(value='', interactive=False), gr.update(interactive=False)

    title = """GPT-3.5 Chatbot""" if DISABLED: title = """This app has reached OpenAI's usage limit. We are currently requesting an increase in our quota. Please check back in a few days.""" description = """Language models can be conditioned to act like dialogue agents through a conversational prompt that typically takes the form:

    User: <utterance>
    Assistant: <utterance>
    User: <utterance>
    Assistant: <utterance>
    ...
    

    In this app, you can explore the outputs of a gpt-3.5 LLM. """

    theme = gr.themes.Default(primary_hue="green")

    with gr.Blocks(css = """#col_container { margin-left: auto; margin-right: auto;} #chatbot {height: 520px; overflow: auto;}""", theme=theme) as demo: gr.HTML(title) gr.HTML("""This app provides you full access to GPT-3.5 (4096 token limit). You don't need any OPENAI API key.""") #gr.HTML('''Duplicate the Space and run securely with your OpenAI API Key''') with gr.Column(elem_id = "col_container", visible=False) as main_block: #API Key is provided by OpenAI #openai_api_key = gr.Textbox(type='password', label="Enter only your OpenAI API key here") chatbot = gr.Chatbot(elem_id='chatbot') #c inputs = gr.Textbox(placeholder= "Hi there!", label= "Type an input and press Enter") #t state = gr.State([]) #s with gr.Row(): with gr.Column(scale=7): b1 = gr.Button(visible=not DISABLED).style(full_width=True) with gr.Column(scale=3): server_status_code = gr.Textbox(label="Status code from OpenAI server", )

        #inputs, top_p, temperature, top_k, repetition_penalty
        with gr.Accordion("Parameters", open=False):
            top_p = gr.Slider( minimum=-0, maximum=1.0, value=1.0, step=0.05, interactive=True, label="Top-p (nucleus sampling)",)
            temperature = gr.Slider( minimum=-0, maximum=5.0, value=1.0, step=0.1, interactive=True, label="Temperature",)
            #top_k = gr.Slider( minimum=1, maximum=50, value=4, step=1, interactive=True, label="Top-k",)
            #repetition_penalty = gr.Slider( minimum=0.1, maximum=3.0, value=1.03, step=0.01, interactive=True, label="Repetition Penalty", )
            chat_counter = gr.Number(value=0, visible=False, precision=0)
    
    with gr.Column(elem_id = "user_consent_container") as user_consent_block:
        # Get user consent
        accept_checkbox = gr.Checkbox(visible=False)
        js = "(x) => confirm('By clicking \"OK\", I agree that my data may be published or shared.')"
        with gr.Accordion("User Consent for Data Collection, Use, and Sharing", open=True):
            gr.HTML("""
            <div>
                <p>By using our app, which is powered by OpenAI's API, you acknowledge and agree to the following terms regarding the data you provide:</p>
                <ol>
                    <li><strong>Collection:</strong> We may collect information, including the inputs you type into our app, the outputs generated by OpenAI's API, and certain technical details about your device and connection (such as browser type, operating system, and IP address) provided by your device's request headers.</li>
                    <li><strong>Use:</strong> We may use the collected data for research purposes, to improve our services, and to develop new products or services, including commercial applications, and for security purposes, such as protecting against unauthorized access and attacks.</li>
                    <li><strong>Sharing and Publication:</strong> Your data, including the technical details collected from your device's request headers, may be published, shared with third parties, or used for analysis and reporting purposes.</li>
                    <li><strong>Data Retention:</strong> We may retain your data, including the technical details collected from your device's request headers, for as long as necessary.</li>
                </ol>
                <p>By continuing to use our app, you provide your explicit consent to the collection, use, and potential sharing of your data as described above. If you do not agree with our data collection, use, and sharing practices, please do not use our app.</p>
            </div>
            """)
            accept_button = gr.Button("I Agree")
    
        def enable_inputs():
            return user_consent_block.update(visible=False), main_block.update(visible=True)
    
    accept_button.click(None, None, accept_checkbox, _js=js, queue=False)
    accept_checkbox.change(fn=enable_inputs, inputs=[], outputs=[user_consent_block, main_block], queue=False)
    
    inputs.submit(reset_textbox, [], [inputs, b1], queue=False)
    inputs.submit(predict, [inputs, top_p, temperature, chat_counter, chatbot, state], [chatbot, state, chat_counter, server_status_code, inputs, b1],)  #openai_api_key
    b1.click(reset_textbox, [], [inputs, b1], queue=False)
    b1.click(predict, [inputs, top_p, temperature, chat_counter, chatbot, state], [chatbot, state, chat_counter, server_status_code, inputs, b1],)  #openai_api_key
             
    demo.queue(max_size=20, concurrency_count=NUM_THREADS, api_open=False).launch(share=False)
    
  2. Assistant

    I'm sorry, can you please provide me with more information on how you want to modify the code?

  3. User

    The main idea of this project is to build a system that can automatically extract relevant information from resumes and store it in a structured format, such as a database. The system uses a combination of natural language processing (NLP) techniques and machine learning models to extract named entities, such as names, email addresses, phone numbers, educational qualifications, work experience, skills, and interests, from resumes.

  4. Assistant

    To modify the code to extract information from resumes, you will need to:

    1. Collect a dataset of resumes that you will use to train your machine learning model. You can either collect this dataset yourself or use an existing dataset.

    2. Preprocess the resumes by removing any unnecessary formatting, such as headers, footers, and tables, and converting the text to a uniform format, such as plain text or HTML.

    3. Train a machine learning model to extract named entities from resumes. You can use a variety of machine learning algorithms, such as rule-based systems, support vector machines (SVM), and deep learning models, such as recurrent neural networks (RNN) and transformer models, such as BERT and XLNet.

    4. Use the trained machine learning model to extract named entities from new resumes. You can either extract the entities directly from the text or use a combination of text and visual information, such as layout and formatting cues, to improve the accuracy of the extraction.

    5. Store the extracted named entities in a structured format, such as a database, that can be easily queried and analyzed.

    Here is a high-level overview of the modifications you can make to the code:

    1. Modify the MODEL variable to use a pre-trained NLP model that is trained on resume data, such as BERT or XLNet.

    2. Modify the predict function to extract the relevant named entities from the input text, using the pre-trained NLP model. You can use existing libraries, such as spaCy or AllenNLP, to perform the entity extraction.

    3. Modify the history variable to store the extracted named entities in a structured format, such as a dictionary or a database. You can create a new function to handle the storage and retrieval of the extracted entities.

    4. Modify the inputs variable to accept resume files instead of text inputs. You can use the gradio.Interface file input feature to allow users to upload resume files.

    5. Modify the state variable to track the extracted named entities across multiple resumes. You can create a new function to merge the extracted entities from multiple resumes into a single structured format.

    These modifications will enable you to build a system that can automatically extract relevant information from resumes and store it in a structured format.

  5. User

    can u give me the finale code

  6. Assistant

    Unfortunately, I cannot provide you with the final code as the modifications you need to make depend on the specific NLP model, machine learning algorithm, and database system you choose to use. However, I can provide you with some general pseudocode that outlines the modifications you need to make:

    import gradio as gr
    import os
    import sys
    import json 
    import requests
    import spacy # or any other NLP library
    import database # or any other database system
    
    # Define the NLP model
    NLP_MODEL = "en_core_web_sm"
    
    # Define the database connection
    DB_URL = "mongodb://localhost:27017/"
    DB_NAME = "resume_db"
    DB_COLLECTION = "resumes"
    
    # Load the NLP model
    nlp = spacy.load(NLP_MODEL)
    
    # Define the database client and collection
    client = database.MongoClient(DB_URL)
    db = client[DB_NAME]
    collection = db[DB_COLLECTION]
    
    # Define the predict function
    def predict(resume_file, request:gr.Request):
        # Load the resume text from the file
        with open(resume_file) as f:
            resume_text = f.read()
        
        # Extract the named entities using the NLP model
        doc = nlp(resume_text)
        entities = {}
        for ent in doc.ents:
            if ent.label_ not in entities:
                entities[ent.label_] = []
            entities[ent.label_].append(ent.text)
        
        # Store the extracted entities in the database
        collection.insert_one(entities)
        
        # Return a success message
        return "Resume processed successfully."
    
    # Define the reset function
    def reset():
        return gr.Interface(predict, gr.inputs.File(label="Upload your resume"), "label").launch()
    
    # Launch the interface
    interface = gr.Interface(predict, gr.inputs.File(label="Upload your resume"), "label", examples=[["resume.pdf"]])
    interface.launch()
    

    This pseudocode assumes that you are using spaCy as the NLP library and MongoDB as the database system. You will need to modify the code to use the specific NLP library and database system that you choose to use.

    The predict function loads the resume text from the file, extracts the named entities using the NLP model, and stores the extracted entities in the MongoDB database. The reset function resets the text box to its default state. The gr.Interface function defines the user interface for the application and the launch method launches the interface.

    Once you've implemented the modifications for your specific use case, you can use Gradio to build a web-based interface that allows users to upload their resumes and extract relevant information automatically.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.