Letzten Monat wurde der Pocket Monster Sword Shield gestartet. Hast du schon mal Pokemon gespielt? Wie jeder, der Pokemon gespielt hat, weiß, hat Pokemon Fähigkeitswerte, die aus HP, Kogeki, Bougyo, Tokukou, Tokubo und Schnelligkeit bestehen. Man kann sagen, dass ein Pokemon mit einem höheren Fähigkeitswert ein stärkeres Pokemon ist. Der Fähigkeitswert wird aus drei Werten berechnet: Rennwert, Einzelwert und Aufwandswert. (Die Formel ist unten geschrieben.) ** Rennwert ** ist der Wert, der für jeden Pokemon-Typ angegeben wird. ** Individueller Wert ** ist ein Wert, der jedem Individuum gegeben wird. Es zeigt, dass dasselbe Pokémon unterschiedliche Stärken hat. ** Aufwandswert ** ist ein erworbener Wert. Der individuelle Wert wird bei der Geburt bestimmt, während der Aufwandswert durch Kampf erhöht werden kann. Dieses Mal möchte ich den Pokemon-Typ aus dem Rennwert mit Python bestimmen.
<Berechnungsformel für die Berechnung des Fähigkeitswertes> </ span> ・ HP Fähigkeitswert = (Rennwert x 2 + Einzelwert + Aufwandswert ÷ 4) x Stufe ÷ 100 + Stufe + 10 ・ Anderer Fähigkeitswert als HP = (Rennwert × 2 + Einzelwert + Aufwandswert ÷ 4) × Stufe ÷ 100 + 5} × Persönlichkeitskorrektur
Als ich nach "Pokemon Machine Learning" suchte, gab es eine Site, die etwas Ähnliches tat, also habe ich sie als Referenz verwendet. https://www.hands-lab.com/tech/entry/3991.html Auf dieser Seite habe ich versucht, anhand des Rennwerts festzustellen, ob es sich um einen Wassertyp handelt, und habe ihn vorerst mit Kopieren und Einfügen implementiert. Ich dachte, es sei ein Erfolg, weil es mit einer Genauigkeit von 85,3% beurteilt wurde, aber in Wirklichkeit wurden nur "Glück" und "Hapinas", die nicht vom Wassertyp sind, als Wassertyp beurteilt.
Lassen Sie uns nun die Situation klären. Es gibt 909 Arten aller Pokémon und 123 Arten von Wassertypen. Es gibt 785 Arten von Pokémon ohne Wasser. Nehmen wir hier ein Modell an, das feststellt, dass es sich nicht um einen Wassertyp handelt, unabhängig davon, welcher Rassenwert eingegeben wird. Die richtige Antwortrate für dieses Modell beträgt 785/909 x 100 = ** 86,5 [%] **.
Mit anderen Worten, beim Problem der binären Klassifizierung können wir sehen, dass die Ergebnisse seltsam sind, wenn nicht die Anzahl der Stichproben der beiden Zielklassifizierungen gleich ist.
Basierend auf meiner Reflexion habe ich die Anzahl der Stichproben der beiden Objekte, die ich klassifizieren möchte, ungefähr gleich gemacht. Dieses Mal möchte ich ein Modell erstellen, das bestimmt, ob es sich um einen Schwerttyp oder einen Schwerttyp handelt. (Hagane-Typ: 58, Denki-Typ: 60) Dieses Mal wurde Pokemon mit Denki- und Hagane-Typ wie einer seltenen Spule als Hagane-Typ gezählt. Pokemon-Daten wurden von hier ausgeliehen.
# %%
import pandas as pd
import codecs
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
with codecs.open("data/pokemon_status.csv", "r", "Shift-JIS", "ignore") as file:
df = pd.read_table(file, delimiter=",")
df.info()
# %%
metal1 = df[df['Typ 1'] == "Hagane"]
metal2 = df[df['Typ 2'] == "Hagane"]
metal = pd.concat([metal1, metal2])
print("Pokemon vom Typ Stahl: %d Tiere" % len(metal))
elec1 = df[df['Typ 1'] == "Denki"]
elec2 = df[df['Typ 2'] == "Denki"]
elec = pd.concat([elec1, elec2])
print("Elektrischer Pokemon: %d Tiere" % len(elec))
def type_to_num(p_type):
if p_type == "Hagane":
return 0
else:
return 1
pokemon_m_e = pd.concat([metal, elec], ignore_index=True)
type1 = pokemon_m_e["Typ 1"].apply(type_to_num)
type2 = pokemon_m_e["Typ 2"].apply(type_to_num)
pokemon_m_e["type_num"] = type1*type2
pokemon_m_e.head()
# %%
X = pokemon_m_e.iloc[:, 7:13].values
y = pokemon_m_e["type_num"].values
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=0)
lr = LogisticRegression(C=1.0)
lr.fit(X_train, y_train)
# %%
print("Punktzahl für Zugdaten: %.3f" % lr.score(X_train, y_train))
print("Punktzahl für Testdaten: %.3f" % lr.score(X_test, y_test))
# %%
i = 0
error1 = 0
success1 = 0
error2 = 0
success2 = 0
print("[Liste der Pokémon vom Typ Hagane]")
print("----------------------------------------")
print("")
while i < len(pokemon_m_e):
y_pred = lr.predict(X[i].reshape(1, -1))
if y_pred == 0:
print(pokemon_m_e.loc[i, ["Pokemon Name"]])
if pokemon_m_e.loc[i, ["type_num"]].values == 0:
success1 += 1
print("Es ist ein Peeling-Typ")
print("")
else:
error1 += 1
print("Es ist kein Peeling-Typ")
print("")
else:
if pokemon_m_e.loc[i, ["type_num"]].values == 0:
error2 += 1
else:
success2 += 1
i += 1
print("----------------------------------------")
print("Anzahl der Pokémon, die als der richtige Typ eingestuft wurden: %d Tiere" % success1)
print("Anzahl der Pokémon, die korrekt als Denki-Typ beurteilt werden: %d Tiere" % success2)
print("Anzahl der Pokémon, die fälschlicherweise als vom Typ beurteilt wurden: %d Tiere" % error1)
print("Anzahl der Pokémon, die fälschlicherweise als Denki-Typ eingestuft wurden: %d Tiere" % error2)
print("")
Anzahl der Pokémon, die als der richtige Typ eingestuft wurden: 48 Anzahl der Pokémon, die korrekt als Denki-Typ eingestuft wurden: 43 Anzahl der Pokémon, die als vom Typ beurteilt wurden, der nicht der Typ des Schwertes ist: 13 Anzahl der Pokémon, die nicht als Hagane-Typ eingestuft wurden, obwohl sie Hagane-Typ waren: 14
Überraschenderweise wurde es richtig beurteilt, daher denke ich, dass es im Allgemeinen erfolgreich war. Rotom wurde als Peeling-Typ eingestuft (lacht).
Im obigen Beispiel wurden der Denki-Typ und der Hagane-Typ verglichen. Insgesamt gibt es 18 Arten von Pokémon, aber ich möchte versuchen, welche Kombination die beste Beurteilungsgenauigkeit bietet.
# %%
import pandas as pd
import codecs
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
with codecs.open("data/pokemon_status.csv", "r", "Shift-JIS", "ignore") as file:
df = pd.read_table(file, delimiter=",")
df.info()
# %%
def lr_model_pokemon(type1, type2, test_size=0.3, random_state=0, C=1.0):
df_type1_1 = df[df['Typ 1'] == type1]
df_type2_1 = df[df['Typ 2'] == type1]
df_type_1 = pd.concat([df_type1_1, df_type2_1])
df_type1_2 = df[df['Typ 1'] == type2]
df_type2_2 = df[df['Typ 2'] == type2]
df_type_2 = pd.concat([df_type1_2, df_type2_2])
def type_to_num(p_type):
if p_type == type1:
return 0
else:
return 1
pokemon_concat = pd.concat([df_type_1, df_type_2], ignore_index=True)
type_num1 = pokemon_concat["Typ 1"].apply(type_to_num)
type_num2 = pokemon_concat["Typ 2"].apply(type_to_num)
pokemon_concat["type_num"] = type_num1 * type_num2
X = pokemon_concat.iloc[:, 7:13].values
y = pokemon_concat["type_num"].values
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=test_size, random_state=random_state)
lr = LogisticRegression(C=C)
lr.fit(X_train, y_train)
return [lr.score(X_train, y_train), lr.score(X_test, y_test)]
# %%
max_score_train = 0
max_score_test = 0
train_type1 = ""
test_type1 = ""
train_type2 = ""
test_type2 = ""
type_list = ["Kusa", "Hono", "Mizu", "Insekt", "normal", "Böse", "Iwa", "Hagane",
"Denki", "Geist", "Drachen", "Esper", "Schließlich", "Doku", "Fee", "Jimen", "Flug", "Koori"]
for type1 in type_list:
for type2 in type_list:
if type1 == type2:
continue
score = lr_model_pokemon(type1=type1, type2=type2)
if (score[0] >= max_score_train):
max_score_train = score[0]
train_type1 = type1
train_type2 = type2
if (score[1] >= max_score_test):
max_score_test = score[1]
test_type1 = type1
test_type2 = type2
print("%s, %Wenn s, wird die Punktzahl für Trainingsdaten maximiert: score = %.3f" %
(train_type1, train_type2, max_score_train))
print("%s, %Wenn s, wird die Punktzahl für die Testdaten maximiert: score = %.3f" %
(test_type1, test_type2, max_score_test))
Es scheint, dass die Genauigkeit des Modells, das zwischen dem Schältyp und dem normalen Typ unterscheidet, am höchsten ist. Nun wollen wir sehen, welche Art von Urteil gefällt wird.
# %%
def poke_predict(type1, type2):
type1_1 = df[df['Typ 1'] == type1]
type2_1 = df[df['Typ 2'] == type1]
type_1 = pd.concat([type1_1, type2_1])
print("%s Typ Pokemon: %d Tiere" % (type1, len(type_1)))
type1_2 = df[df['Typ 1'] == type2]
type2_2 = df[df['Typ 2'] == type2]
type_2 = pd.concat([type1_2, type2_2])
print("%s Typ Pokemon: %d Tiere" % (type2, len(type_2)))
def type_to_num(p_type):
if p_type == type1:
return 0
else:
return 1
poke_concat = pd.concat([type_1, type_2], ignore_index=True)
type1_c = poke_concat["Typ 1"].apply(type_to_num)
type2_c = poke_concat["Typ 2"].apply(type_to_num)
poke_concat["type_num"] = type1_c*type2_c
poke_concat.head()
X = poke_concat.iloc[:, 7:13].values
y = poke_concat["type_num"].values
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=0)
lr = LogisticRegression(C=1.0)
lr.fit(X_train, y_train)
i = 0
error1 = 0
success1 = 0
error2 = 0
success2 = 0
print("")
print("[%Liste der Pokémon, die als s-Typ eingestuft wurden]" % type1)
print("----------------------------------------")
print("")
while i < len(poke_concat):
y_pred = lr.predict(X[i].reshape(1, -1))
if y_pred == 0:
print(poke_concat.loc[i, ["Pokemon Name"]])
if poke_concat.loc[i, ["type_num"]].values == 0:
success1 += 1
print("%s Typ" % type1)
print("")
else:
error1 += 1
print("%Nicht s Typ" % type1)
print("")
else:
if poke_concat.loc[i, ["type_num"]].values == 0:
error2 += 1
else:
success2 += 1
i += 1
print("----------------------------------------")
print("Korrekt%Anzahl der Pokémon, die als s-Typ beurteilt wurden: %d Tiere" % (type1, success1))
print("Korrekt%Anzahl der Pokémon, die als s-Typ beurteilt wurden: %d Tiere" % (type2, success2))
print("Versehentlich%Anzahl der Pokémon, die als s-Typ beurteilt wurden: %d Tiere" % (type1, error1))
print("Versehentlich%Anzahl der Pokémon, die als s-Typ beurteilt wurden: %d Tiere" % (type2, error2))
print("")
# %%
poke_predict("Hagane", "normal")
Anzahl der Pokémon, die als die richtige Art des Spritzens eingestuft wurden: 50 Anzahl der Pokémon, die korrekt als normaler Typ eingestuft wurden: 115 Anzahl der Pokémon, die fälschlicherweise als Spritztyp identifiziert wurden: 1 Anzahl der Pokémon, die fälschlicherweise als normaler Typ identifiziert wurden: 8
Obwohl es einen Unterschied in der Anzahl der Proben gibt, kann die Genauigkeit von 94,8% als ziemlich gut bezeichnet werden. Aus diesem Ergebnis kann gesagt werden, dass sich die Eigenschaften des Rennwerts zwischen dem normalen Typ und dem Schwerttyp unterscheiden.
Ich bin ein Anfänger weniger als eine Woche, nachdem ich angefangen habe, maschinelles Lernen zu lernen, aber ich glaube, ich konnte tief nachdenken. Wenn Sie in diesem Artikel falsche Gedanken haben, würde ich mich freuen, wenn Sie darauf hinweisen könnten.
Recommended Posts