Cet article explique comment améliorer l'efficacité en utilisant des boucles de traitement d'exclusion dans IQ Bot.
L'exclusion est une sorte de remplacement, donc l'idée est fondamentalement la même, mais je pense que le remplacement est probablement un peu plus difficile en termes de codage, alors je l'ai coupé ici.
Dans le cas du traitement du remplacement en boucle, la rencontre la plus courante est "l'alignement du kana demi-largeur". ABBYY, l'un des moteurs OCR intégrés à IQ Bot, a tendance à être un peu faible dans la lecture des kana demi-largeur.
Si vous voulez simplement lire la demi-largeur en pleine largeur (ou vice versa), vous pouvez la corriger du côté RPA avec l'action de conversion japonaise demi-largeur ⇔ pleine largeur dans le Bot Store, mais "ga" est remplacé par "ka". Il y a des cas où il est lu comme "(ka + double guillemet)", et je pense qu'il est plus rapide de le faire avec Python que de le faire correctement avec RPA.
(Bien que vous puissiez écrire Python avec RPA)
La différence entre l'exclusion et le remplacement est la suivante en termes de logique d'élément de champ.
Différence entre exclusion et remplacement
#Ceci est exclu
field_value = field_value.replace("Chaîne de caractères à exclure","")
#C'est le remplacement
field_value = field_value.replace("Chaîne de caractères avant remplacement","Chaîne de caractères après remplacement")
La grammaire de base est "remplacement", et l'exclusion est réalisée en remplaçant la "chaîne de caractères après remplacement" par "" "` (= chaîne de caractères vide).
Dans le cas de l'exclusion, la chaîne de caractères après remplacement était toujours fixée à "" ", donc les seuls éléments multiples étaient "" chaîne de caractères à exclure " (= chaîne de caractères avant remplacement).
Ainsi, la séquence à boucler était OK avec la structure du tableau primaire.
Par contre, dans le cas du remplacement, il y a plusieurs avant et après remplacement, il faut donc mettre avant et après remplacement dans la séquence comme un ensemble. La structure du tableau secondaire.
C'est le point UP du niveau de difficulté.
Mais ne t'inquiète pas. Oui ... Non, je vais vous l'expliquer correctement.
Le processus de remplacement est complété par la structure suivante.
Concept de traitement de remplacement
replace_list = (("Chaîne de caractères avant remplacement 1","Chaîne de caractères après remplacement 1"),
("Chaîne de caractères avant remplacement 2","Chaîne de caractères après remplacement 2"),
("Chaîne de caractères avant remplacement 3","Chaîne de caractères après remplacement 3"))
for i in replace_list:
field_value = field_value.replace(i[0],i[1])
replace_list a un taple à l'intérieur du tapple, c'est-à-dire qu'il a une structure de tableau quadratique.
Dans ʻidans la boucle for,(" chaîne de caractères avant remplacement 1 "," chaîne de caractères après remplacement 1 ")pour le premier traitement,(" "pour le deuxième traitement L'enfant taple est entré comme chaîne de caractères avant le remplacement 2 "," chaîne de caractères après le remplacement 2 ")`.
Le mécanisme est que les éléments d'index 0 (ʻi [0] / avant remplacement) et 1 (ʻi [1] / après remplacement) sont retirés du ʻi et passés à l'argument de remplacer`. ..
À propos, la logique de correction du kana demi-largeur donnée dans l'exemple au début est une telle image.
Processus de remplacement pour kana demi-largeur
replace_list = (('Puissance"','Géorgie'),('Ki"','Gi'),('Ku"','Gu'),('Ke"','Ge'),('Ko"','Aller'),
('Un service"','le'),('Shi"','le'),('Su"','Zu'),('Se"','Ze'),('Alors"','Zo'),
('Ta"','Da'),('Ji"','Di'),('Tsu"','Zu'),('Te"','De'),('À"','Faire'),
('C"','Ba'),('salut"','Bi'),('Fu"','Bu'),('F"','Être'),('E"','Bo'),
('Ha °','Pennsylvanie'),('Salut °','Pi'),('° F','Pu'),('° F','Pe'),('Ho °','Po'))
for i in replace_list:
field_value = field_value.replace(i[0],i[1])
En supposant que le point de turbidité est lu comme "" "(double citation) et le point de semi-turbidité est lu comme" ° "(degré), il s'agit d'un processus d'alignement sur un kana pleine largeur.
En réalité, la lecture des points troubles et des points semi-troubles fluctue souvent un peu plus.
Il est efficace d'appliquer ce processus après avoir unifié les résultats de lecture des points troubles et des points semi-troubles par un traitement de remplacement normal tout en regardant les résultats OCR.
Dans le cas d'une table, vous pouvez modifier le contenu de la boucle for pour la table, cela devrait donc fonctionner comme suit.
Processus de remplacement (pour les tables)
replace_list = (("Chaîne de caractères avant remplacement 1","Chaîne de caractères après remplacement 1"),
("Chaîne de caractères avant remplacement 2","Chaîne de caractères après remplacement 2"),
("Chaîne de caractères avant remplacement 3","Chaîne de caractères après remplacement 3"))
for i in replace_list:
df['Nom de colonne'] = df['Nom de colonne'].str.replace(i[0],i[1])
Mais ce qui précède n'est pas très beau ... Suis-je le seul à ressentir?
Je ferais ça.
Processus de remplacement (pour les tables)
replace_list = (("Chaîne de caractères avant remplacement 1","Chaîne de caractères après remplacement 1"),
("Chaîne de caractères avant remplacement 2","Chaîne de caractères après remplacement 2"),
("Chaîne de caractères avant remplacement 3","Chaîne de caractères après remplacement 3"))
def table_replace(x,y):
for i in y:
x = x.y(i[0],i[1])
return x
df['Nom de colonne'] = df['Nom de colonne'].apply(table_replace,y=replace_list)
Si tu fais ça
--Lorsque vous souhaitez appliquer la même combinaison de chaînes de caractères à remplacer, mais à des colonnes différentes --Lorsque vous souhaitez modifier la combinaison de chaînes de caractères que vous souhaitez remplacer en fonction de la colonne
Il sera possible de réagir avec souplesse à de tels cas.
Processus de remplacement (pour les tables)
replace_listA = (("Chaîne de caractères avant remplacement 1","Chaîne de caractères après remplacement 1"),
("Chaîne de caractères avant remplacement 2","Chaîne de caractères après remplacement 2"),
("Chaîne de caractères avant remplacement 3","Chaîne de caractères après remplacement 3"))
replace_listB = (("Chaîne de caractères avant remplacement a","Chaîne de caractères après remplacement a"),
("Chaîne de caractères avant remplacement b","Chaîne de caractères après remplacement b"),
("Chaîne de caractères avant remplacement c","Chaîne de caractères après remplacement c"))
def table_replace(x,y):
for i in y:
x = x.y(i[0],i[1])
return x
df['Nom de colonne 1'] = df['Nom de colonne 1'].apply(table_replace,y=replace_listA)
df['Nom de colonne 1'] = df['Nom de colonne 1'].apply(table_replace,y=replace_listB)
df['Nom de colonne 2'] = df['Nom de colonne 2'].apply(table_replace,y=replace_listA)
df['Nom de colonne 3'] = df['Nom de colonne 3'].apply(table_replace,y=replace_listB)
C'est le point.
Appliquer les remplacements replace_listA et replace_listB au nom de colonne 1
Seul remplacer par replace_listA est appliqué au nom de colonne 2
Voici un exemple dans lequel seul le remplacement par replace_listB est appliqué au nom de colonne 3.
Hmmm, n'était-ce pas difficile?
Si vous avez des questions, laissez un commentaire sur cet article ou contactez-nous via DM sur Twitter.
Recommended Posts