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, # limits the length of the generated text. temperature=0, # controls the randomness of the output. Lower values are more deterministic. top_p=0, # controls diversity of the slection of the tokens. Lower values means selecting the most probable tokens. echo=True # includes the prompt in the output if True. ) 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 files, we can use the "save_pretrained" method from the Hugging Face Transformers library.

Ideally, you will save all related files in the same folder.

Note that saving the model also saves its configuration file.

• Save the model and its associated configuration files:
  from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-small") path = "./models/microsoft/model/dialogpt-small" model.save_pretrained(path)
  This will create a directory containing:
  $ ls -1 models/microsoft/model/dialogpt-small/ config.json generation_config.json model.safetensors
  
• Save the model tokenizer files:
  from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-small") path = "./models/microsoft/tokenizer/dialogpt-small" tokenizer.save_pretrained(path)
  This will create a directory containing:
  $ ls -1 models/microsoft/tokenizer/dialogpt-small/ merges.txt special_tokens_map.json tokenizer.json tokenizer_config.json vocab.json
  
• Save only the model configuration file.:
  from transformers import AutoConfig config = AutoConfig.from_pretrained("microsoft/DialoGPT-small") path = "./models/microsoft/config/dialogpt-small" config.save_pretrained(path)
  This will create a directory containing:
  $ ls -1 models/microsoft/config/dialogpt-small/ config.json
  

Files:

• config.json: The configuration file of the model.
  { "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.
  { "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.
  
  
• generation_config.json, merges.txt

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

Ideally, you will have saved all related files in the same folder.

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)