The Hugging Face Hub is an open platform with over 1 million models that can be used to process and generate text, images, audio, video, ...
https://huggingface.co/models

Selecting a model depends on:

• The underlying architecture of the model (representation/generative model)
  
• The size of the model
  
• The performance of the model
  
• The task to be executed by the model
  
• The languages supported by the model
  
• ...
  

You can use the Hugging Face Embedding Leaderboard. It compares models across many languages.
https://huggingface.co/spaces/mteb/leaderboard

You can use the Hugging Face CLI to download a model: $ huggingface-cli download microsoft/DialoGPT-small
Sample python coe to generate text:
# import the model and the tokenizer objects from the Transformers library from transformers import AutoModelForCausalLM, AutoTokenizer # Load the model and its tokenizer model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-small") # Load the model's tokenizer tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-small") # Toknize the input input_ids = tokenizer.encode("Make a joke about AI.", return_tensors='pt') # Generate the text output = model.generate( input_ids=input_ids, max_new_tokens=50 ) print(tokenizer.decode(output[0]))

Sample python coe to use a pipeline:
# import the model and the tokenizer objects from the Transformers library from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline # Load the model and its tokenizer model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-small") # Load the model's tokenizer tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-small") # Create a pipeline object for the "text-generation" task pipe = pipeline( "text-generation", model=model, tokenizer=tokenizer, max_new_tokens=50 ) # Prompt Pipeline with some initial text to generate more text. output = pipe("Make a joke about AI.") print(output[0]["generated_text"])

Download this model:
$ wget https://huggingface.co/microsoft/Phi-3-mini-4k-instruct-gguf/resolve/main/Phi-3-mini-4k-instruct-q4.gguf
Python code:
from llama_cpp import Llama model = Llama(model_path="Phi-3-mini-4k-instruct-q4.gguf") prompt = """ Question: What's 1+1? """ output = model( prompt, max_tokens=50, temperature=0, stop=["Q:", "\n"] ) print(output["choices"][0]["text"])

There are few parameters that can affect the output of the model:

• The model's context length:
  A model has a context length (a.k.a. the context window, context size, token limit):
  
  • The context length represents the maximum number of tokens the model can process.
    
  • Generative models are autoregressive, so the current context length will increase as new tokens are generated.
    
  
  
• return_full_text:
  If set to "False", only the model output is returned.
  Otherwise, the full text is returned; including the user prompt.
  
  
• max_new_tokens:
  It sets the maximum number of tokens the model can generate.
  
  
• do_sample:
  The model decides the probability of all possible values ​​of the next token. It sorts the next possible tokens based on their probability of being chosen.
  
  If the "do_sample" parameter is set to "False", the model selects the most probable next token; this leads to a more predictable and consistent response. Otherwise, the model will sample from the probability distribution, leading to more possible tokens that can be chosen by the model.
  
  When we set the "do_sample" parameter to true, we can also use the "temperature" parameter to make the output more "random". Hence we can get different output for the same prompt.
  
  
• temperature:
  It controls the probability that the model can choose less likely tokens.
  
  When we set the "temperature" parameter to 0 (deterministic), the model should always generate the same response when given the same prompt.
  
  The closer the value of the "temperature" parameter is to 1 (high randomness), the more likely we are to get a random output.
  

ChatGPT (OpenAI) is a proprietary model. The model can be accessed through OpenAI's API.
You need to sign-up and create an API key here: https://platform.openai.com/api-keys
The API key will be used to communicate with OpenAI's API.

To try out your new API key with curl:
curl https://api.openai.com/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer YOUR_API_KEY" \ -d '{ "model": "gpt-4o-mini", "store": true, "messages": [ {"role": "user", "content": "write a haiku about ai"} ] }'
To try out your new API key with Python:

Install the OpenAI Python SDK:
$ pip install openai
Check OpenAI Python SDK installation:
$ pip show openai Name: openai Version: 1.76.0 ...
Execute the code below to generate a haiku for free using the gpt-4o-mini model. from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY" ) completion = client.chat.completions.create( model="gpt-4o-mini", store=True, messages=[ {"role": "user", "content": "write a haiku about ai"} ] ) print(completion.choices[0].message);

To save a model, tokenizer, and configuration, we can use the "save_pretrained" method from the Hugging Face Transformers library.

from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-small") tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-small") config = AutoConfig.from_pretrained("microsoft/DialoGPT-small") path = "./models/microsoft/dialogpt-small" model.save_pretrained(path) tokenizer.save_pretrained(path) config.save_pretrained(path)
This will create a directory containing:

• config.json: The configuration file of the model.
  $ cat microsoft/dialogpt-small/config.json | jq { "activation_function": "gelu_new", "architectures": [ "GPT2LMHeadModel" ], "attn_pdrop": 0.1, "bos_token_id": 50256, "embd_pdrop": 0.1, "eos_token_id": 50256, "initializer_range": 0.02, "layer_norm_epsilon": 0.00001, "model_type": "gpt2", "n_ctx": 1024, "n_embd": 768, "n_head": 12, "n_inner": null, "n_layer": 12, "n_positions": 1024, "reorder_and_upcast_attn": false, "resid_pdrop": 0.1, "scale_attn_by_inverse_layer_idx": false, "scale_attn_weights": true, "summary_activation": null, "summary_first_dropout": 0.1, "summary_proj_to_labels": true, "summary_type": "cls_index", "summary_use_proj": true, "task_specific_params": { "conversational": { "max_length": 1000 } }, "transformers_version": "4.51.3", "use_cache": true, "vocab_size": 50257 }
  
• tokenizer_config.json: The configuration file of the tokenizer.
  $ cat microsoft/dialogpt-small/tokenizer_config.json | jq { "add_bos_token": false, "add_prefix_space": false, "added_tokens_decoder": { "50256": { "content": "<|endoftext|>", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": true } }, "bos_token": "<|endoftext|>", "chat_template": "{% for message in messages %}{{ message.content }}{{ eos_token }}{% endfor %}", "clean_up_tokenization_spaces": true, "eos_token": "<|endoftext|>", "errors": "replace", "extra_special_tokens": {}, "model_max_length": 1024, "pad_token": null, "tokenizer_class": "GPT2Tokenizer", "unk_token": "<|endoftext|>" }
  
• vocab.json, tokenizer.json: contain the vocabulary and the mapping of tokens to IDs.
  
  
• special_tokens_map.json: contains the mapping of special tokens used by the tokenizer.
  
  
• model.safetensors: contains the model's weights.
  
• special_tokens_map.json, generation_config.json, merges.txt

To load the saved model, tokenizer, and configuration, we can use the "from_pretrained" method from the Hugging Face Transformers library.

from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig path = "./models/microsoft/dialogpt-small" model = AutoModelForCausalLM.from_pretrained(path) tokenizer = AutoTokenizer.from_pretrained(path) config = AutoConfig.from_pretrained(path)