Panduan Lengkap Untuk Membangun Chatbot Twitter Dengan GPT3 Dan Replit

Membuat kembali SmarterChild di Twitter dengan Python, GPT3, dan Replit

Jika Anda generasi tahun 90-an maka Anda ingat mengotak-atik SmarterChild di komputer desktop Anda, yang mungkin terlihat seperti ini.

Smarterchild ada di depan waktunya. Sekarang, dengan munculnya OpenAI dan GPT3, kami siap untuk membuat kembali ingatan lama kami, dengan mesin baru di bawah the hood.

No	Prasyarat:
1	Kunci API OpenAI
2	Akun Developer Twitter
3	Nama Pengguna Bot Twitter
4	Tweepy
5	Python
6	Replit

Anda bisa menemukan kode saya untuk posting ini di Replit.

Otentikasi Dengan OpenAI

Langkah pertama ialah membuat akun OpenAI gratis. Meskipun pembuatan akun gratis, untuk melakukan panggilan ke mesin GPT3, Anda perlu menambahkan info penagihan.

Saya sarankan menggunakan model Davinci untuk Chatbot Twitter Anda. Ini akan memberi Anda sekitar $0,0200 / 1K token. Dengan kata lain, dua sen per ~750 kata. Anda bisa melihat detail harga lebih lanjut di sini.

Setelah mendaftar dan menambahkan info tagihan, Anda siap mengakses Kunci API OpenAI.

Salin kunci rahasia dan simpan di dalam Repl Python baru Anda. Jika Anda bertanya pada diri sendiri, "apa itu Repl?" maka Anda perlu meluangkan waktu untuk mempelajari lebih dalam ke dunia Replit.

Replit menangani environment variables dengan cara yang baik dan mudah. Cukup buat rahasia baru, beri nama OPENAI_KEY dan menyatukan kunci rahasia OpenAI API Anda yang telah disalin ke dalam nilainya.

Anda juga dapat menyimpannya dalam file .env jika Anda menjalankannya secara lokal. Anda harus menggunakan python-dotenv jika Anda menggunakan rute ini.

Di dalam file main.py Repl, Anda harus mengakses kunci rahasia sebagai environment variables. Anda dapat melakukannya dengan kode berikut:

my_secret = os.environ[‘OPENAI_KEY’]

Anda perlu mengganti my_secret dengan openai.api_key sehingga terlihat seperti ini:

openai.api_key = os.environ[‘OPENAI_KEY’]

Di sini Anda menyiapkan klien openai API dengan mengambil environment variables bernama OPENAI_KEY dan memulainya sebagai openai.api_key. Kunci API ini digunakan untuk mengautentikasi dan mengotorisasi klien yang membuat permintaan API ke GPT3.

Buat Akun Developer Twitter

Pergilah ke Portal Developer Twitter, dengan asumsi itu masih ada saat Anda menyiapkan ini, dan buat akun Developer baru secara gratis (atau sampai Elon membuat Anda membuat beberapa bahan).

Ikuti langkah-langkah untuk membuat aplikasi baru di Environment Developer. Setelah Anda memberi nama aplikasi, deskripsi, dan ikon aplikasi, buka tab Kunci dan Token.

No	Ada 4 token autentikasi yang perlu Anda salin:
1	Kunci Konsumen
2	Rahasia Konsumen
3	Akses Token
4	Rahasia Token Akses

Sama seperti OpenAI API Key, salin dan tempel token autentikasi Twitter Anda sebagai rahasia Replit. Beri mereka nama-nama berikut:

Anda kemudian perlu mengambil rahasia di file main.py python Anda:

consumer_key = os.environ[‘TWITTER_CONSUMER_KEY’]
consumer_secret = os.environ[‘TWITTER_CONSUMER_SECRET’]
access_token = os.environ[‘TWITTER_ACCESS_TOKEN’]
access_token_secret = os.environ[‘TWITTER_ACCESS_TOKEN_SECRET’]

Gunakan Tweepy untuk Berinteraksi dengan Twitter API

Untuk tutorial ini, Anda akan menggunakan Tweepy sebagai case API Twitter. Anda dapat menemukan dokumentasi Tweepy di sini.

Otentikasi Dengan Tweepy

Setelah mengimpor kunci autentikasi, token, dan rahasia, Anda perlu menginisialisasi OAuthUserHandler dengan keempat kredensial, lalu membuat objek api dengan instance OAuthUserHandler.

# Authenticate using the keys
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)

# Create an API class object
api = tweepy.API(auth)

Objek kelas api yang baru dibuat memberi Anda akses ke semua metode API Twitter. Metode ini menerima berbagai parameter dan mengembalikan respons yang berbeda. Untuk tujuan bot balasan Anda, Anda akan menggunakan metode mentions_timeline().

Get User Mentions

Sekarang Anda siap mengakses semua tweet yang menyebutkan nama pengguna tertentu. Nama pengguna bot akan dikaitkan dengan token autentikasi Twitter Anda sehingga Anda tidak perlu mereferensikannya di file python.

Seperti yang disebutkan sebelumnya, Anda akan memanggil metode mentions_timeline() pada objek kelas api untuk mendapatkan semua penyebutan nama pengguna bot Anda. Simpan ke dalam variabel status sehingga kita dapat mengulanginya dalam for loop. Anda mungkin merasa terbantu untuk mencetak jumlah status yang diambil dengan pernyataan cetak yang praktis.

# fetch the mentions with mentions_timeline
statuses = api.mentions_timeline()
print(str(len(statuses)) + “ bot mentions”)

Karena ini adalah bot baru, sepertinya tidak akan banyak yang menyebutkan. Tapi jangan takut, menjalankan akun firebug Anda, pour red wine untuk diri Anda sendiri dan mulailah men-tweet. Untuk info lebih lanjut tentang cara menggunakan metode mentions_timeline() lihat dokumentasi Tweepys di sini.

Langkah selanjutnya adalah mengulang semua tweet dalam variabel status dan mengekstrak status.id untuk masing-masing. Dengan id Anda dapat menggunakan metode get_status() untuk mendapatkan teks lengkap dari setiap tweet. Ini diperlukan untuk Tweet dengan panjang lebih dari 180 karakter atau luxury embedding lainnya. Simpan extended_status.full_text , yang sebenarnya hanyalah seluruh teks tweet, ke dalam variabel prompt.

for status in statuses:
  # fetching the status with extended tweet_mode
  id = status.id
  extended_status = api.get_status(id, tweet_mode=”extended”)
  prompt = extended_status.full_text
  print(prompt)

Luar biasa, Anda sekarang memiliki id dan teks untuk setiap tweet yang menyebutkan bot Anda. Anda akan menggunakan ini sebagai input cepat untuk GPT3.

Menghasilkan Balasan Twitter dengan GPT3

Untuk menghidupkan bot Anda, Anda akan menggunakan metode Completion.create() pada klien openAi yang Anda autentikasi sebelumnya. Metode ini digunakan untuk menghasilkan respons untuk setiap masukan yang diberikan, yang dalam kasus Anda adalah Tweet.

No	Metode Completion.create() memerlukan parameter berikut:
1	prompt
2	max_tokens
3	temperature
4	engine

Karena bot Anda men-tweet, max_token harus 280 karena Twitter tidak menerima tweet yang lebih panjang. Parameter suhu akan menentukan seberapa wild or stiff bot yang Anda inginkan.

Simpan respons yang dihasilkan ke dalam variabel r dan bersihkan respons sehingga Anda hanya memiliki teks, yang akan Anda masukkan kembali ke tweepy sebagai balasan.

r = openai.Completion.create(
  engine="text-davinci-003",
  prompt=prompt,
  max_tokens=280,
  temperature=0.5,
 )

# clean up response
response = r.choices[0].text.strip()

Jika Anda mencetak respons, Anda akan melihat GPT3 bekerja. Selamat telah berhasil sejauh ini, Anda hampir sampai.

Selanjutnya, berikan respons ke metode update_status() Tweepy yang akan menge-tweet atas nama bot Anda. Pastikan untuk meneruskan parameter in_reply_to_status_id sehingga parameter tersebut membalas penyebutan Twitter yang benar yang digunakan sebagai teks prompt.

# Respond to the tweet
 api.update_status(“@” + status.user.screen_name + “ “ + response, in_reply_to_status_id=status.id)

Jika Anda menjalankan ini dan memeriksa Twitter, Anda akan melihat respons bot Anda!

Simpan Tweet yang Diproses di Database SQLlite

Skrip seharusnya berfungsi dengan baik pada saat ini. Tapi yang mungkin Anda lihat adalah bot Anda merespons tweet yang sama berulang kali. Untuk mencegahnya, Anda perlu membuat database untuk menyimpan id tweet yang telah ditanggapi oleh bot Anda.

Buat database sqlite baru di replit hanya dengan menjalankan:

# Create the database and connection
connection = sqlite3.connect(“my_database”)

Replit akan secara otomatis mengunduh sqlite3.

Dari sana praktik terbaiknya adalah membuat kursor untuk database sehingga Anda dapat mengeksekusi pernyataan.

# Create a cursor for the database to execute statements
cursor = connection.cursor()

Buat tabel "tweets" yang menyertakan id, pengguna, dan teks tweet. Id akan menjadi kunci utama, sedangkan pengguna dan teks bagus untuk dimiliki.

# create tweets table if it doesn’t exist
cursor.execute(
 “””
 CREATE TABLE IF NOT EXISTS tweets (
 id integer PRIMARY KEY,
 user text,
 text text
 );
 “””
)

Setelah tabel dibuat, Anda dapat menjalankan pernyataan SQL untuk mendapatkan semua id tweet di database dan menyimpannya ke dalam variabel hasil:

# get all of the tweet ids in the database
cursor.execute(“SELECT id from tweets”)
result = cursor.fetchall()

Jika Anda mencetak hasil, Anda akan melihat bahwa itu bukan objek yang dapat Anda ulangi dengan mudah dengan python.

Untuk menyiasatinya, Anda harus mengonversinya menjadi daftar. Cara termudah yang saya temukan untuk melakukannya adalah pertama mengubahnya menjadi kerangka data dan kemudian mengonversi kolom id dari kerangka data menjadi daftar. Simpan daftar baru ini sebagai processing_mentions.

# convert result to a dataframe and create a list
df = pd.DataFrame(result, columns=[‘id’])
processed_mentions = df[‘id’].to_list()

Sekarang, sebelum menanggapi setiap tweet, Anda dapat mengulangi proses_mentions dan memeriksa apakah tweet yang Anda ambil dari metode api.mentions_timeline() telah diproses. Jika sudah, Anda dapat melewatinya dengan melanjutkan :

if status.id in processed_mentions:
  print(“skipping status “ + str(status.id))
  continue

Bagian terakhir dari teka-teki ini adalah membuat fungsi untuk menambahkan tweet yang baru dibalas ke dalam database Tweet. Untuk ini, buat fungsi baru bernama add_to_processed() yang menggunakan status sebagai parameter.

Dengan status, atur kolom id, user dan text sama dengan id, user.screen_name dan text dari status alias tweet:

# function to add status to sqlite3 database
def add_to_processed(status):
  insert_query = (“INSERT INTO tweets (id,user,text)”
  “VALUES (:id, :user, :text);”)
  
  tweet_parameters = {
   'id': status.id,
   'user': status.user.screen_name,
   'text': status.text
  }
  
  return connection.execute(insert_query, tweet_parameters)

Sekarang ketika Anda memperbarui for loop yang mengulang setiap status dalam status, Anda dapat meneruskan status itu ke fungsi add_to_processed() . Ini akan memasukkan info yang relevan ke dalam database sehingga dilewati di lain waktu. Kode akhir Anda akan terlihat seperti ini.

for status in statuses:
  # skip status if its in processed mentions
  if status.id in processed_mentions:
    print(“skipping status “ + str(status.id))
    continue
  
  # fetching the status with extended tweet_mode
  id = status.id
  extended_status = api.get_status(id, tweet_mode="extended")
  add_to_processed(status)
  prompt = extended_status.full_text

  r = openai.Completion.create(
   engine="text-davinci-003",
   prompt=prompt,
   max_tokens=280,
   temperature=0.5,
   )

  # clean up response
  response = r.choices[0].text.strip()
 
  # Respond to the tweet
  api.update_status("@" + status.user.screen_name + " " + response, in_reply_to_status_id=status.id)

Bagus! Bit terakhir dari sqlite3 housekeeping menjalankan operasi komit dan di tutup di akhir file main.py Anda.

# Commit changes
connection.commit()

# Close the connection
connection.close()

Voila. Anda sekarang harus memiliki bot balasan Twitter yang berfungsi yang menyebutkan, menggunakannya sebagai prompt untuk GPT3, membalas tweet itu menggunakan tweepy dan kemudian menyimpan id tweet itu ke dalam database sqlite3 di replit.

Jika Elon belum membakar twitter, selamat menikmati.